{"$schema":"https://echarts.apache.org/doc/json-schem","option":{"type":"Object","properties":{"title":{"type":["Object"],"description":"<p>Title component, including main title and subtitle.</p>\n<p>In ECharts 2.x, a single instance of ECharts could contains one title component at most. However, in ECharts 3, there could be one or more than one title components. It is more useful when multiple diagrams in one instance all need titles.</p>\n<p><strong>Here are some instances of different animation easing functions, among which every instance has a title component: </strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-easing&edit=1&reset=1\" width=\"700\" height=\"400\"></iframe>\n\n\n\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the title from showing</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"text":{"type":["string"],"description":"\n\n<p>The main title text, supporting for <code class=\"codespan\">\\n</code> for newlines.</p>\n","uiControl":{"type":"text"},"default":"''"},"link":{"type":["string"],"description":"<p>The hyper link of main title text.</p>\n","default":"''"},"target":{"type":["string"],"description":"<p>Open the hyper link of main title in specified tab.</p>\n<p><strong>options: </strong></p>\n<ul>\n<li><p><code class=\"codespan\">&#39;self&#39;</code> opening it in current tab</p>\n</li>\n<li><p><code class=\"codespan\">&#39;blank&#39;</code> opening it in a new tab</p>\n</li>\n</ul>\n","default":"'blank'"},"textStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>main title text color.</p>\n","uiControl":{"type":"color","default":"'#333'"},"default":"'#333'"},"fontStyle":{"type":["string"],"description":"\n\n<p>main title font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p>main title font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"'bolder'"},"fontFamily":{"type":["string"],"description":"\n\n<p>main title font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p>main title font size.</p>\n","uiControl":{"type":"number","default":"18","min":"1","step":"1"},"default":18},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"subtext":{"type":["string"],"description":"\n\n<p>Subtitle text, supporting for <code class=\"codespan\">\\n</code> for newlines.</p>\n","uiControl":{"type":"text"},"default":"''"},"sublink":{"type":["string"],"description":"<p>The hyper link of subtitle text.</p>\n","default":"''"},"subtarget":{"type":["string"],"description":"<p>Open the hyper link of subtitle in specified tab, options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;self&#39;</code> opening it in current tab</p>\n</li>\n<li><p><code class=\"codespan\">&#39;blank&#39;</code> opening it in a new tab</p>\n</li>\n</ul>\n","default":"'blank'"},"subtextStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>subtitle text color.</p>\n","uiControl":{"type":"color","default":"'#aaa'"},"default":"'#aaa'"},"fontStyle":{"type":["string"],"description":"\n\n<p>subtitle font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p>subtitle font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p>subtitle font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p>subtitle font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"textAlign":{"type":["string"],"description":"\n\n<p>The horizontal align of the component (including &quot;text&quot; and &quot;subtext&quot;).</p>\n<p>Optional values: <code class=\"codespan\">&#39;auto&#39;</code>, <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"auto,left,center,right","default":"auto"},"default":"'auto'"},"textVerticalAlign":{"type":["string"],"description":"\n\n<p>The vertical align of the component (including &quot;text&quot; and &quot;subtext&quot;).</p>\n<p>Optional values: <code class=\"codespan\">&#39;auto&#39;</code>, <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"auto,top,middle,bottom","default":"auto"},"default":"'auto'"},"triggerEvent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code> to enable triggering events</p>\n","default":false},"padding":{"type":["number","Array"],"description":"\n\n<p>title space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"itemGap":{"type":["number"],"description":"\n\n<p>The gap between the main title and subtitle.</p>\n","uiControl":{"type":"number","min":"0","default":"10","step":"1"},"default":10},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between title  component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'auto'"},"top":{"type":["string","number"],"description":"<p>Distance between title  component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'auto'"},"right":{"type":["string","number"],"description":"<p>Distance between title  component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"bottom":{"type":["string","number"],"description":"<p>Distance between title  component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"backgroundColor":{"type":["Color"],"description":"\n\n<p>Background color of title, which is transparent by default.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>.</p>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of title. Support the same color format as backgroundColor.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of title.</p>\n","uiControl":{"type":"number","default":"0","min":"0","step":"0.5"},"default":1},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>The radius of rounded corner. Its unit is px. And it supports use array to respectively specify the 4 corner radiuses.</p>\n<p>For example:</p>\n<pre><code>borderRadius: 5, // consistently set the size of 4 rounded corners\nborderRadius: [5, 5, 0, 0] // (clockwise upper left, upper right, bottom right and bottom left)\n</code></pre>","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"},"default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n<p><strong>Attention</strong>: This property works only if <code class=\"codespan\">show: true</code> is configured and <code class=\"codespan\">backgroundColor</code> is defined other than <code class=\"codespan\">transparent</code>.</p>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n<p><strong>Attention</strong>: This property works only if <code class=\"codespan\">show: true</code> configured.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n<p><strong>Attention</strong>: This property works only if <code class=\"codespan\">show: true</code> configured.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n<p><strong>Attention</strong>: This property works only if <code class=\"codespan\">show: true</code> configured.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"legend":{"type":["Object"],"description":"<p>Legend component.</p>\n<p>Legend component shows symbol, color and name of different series. You can click legends to toggle displaying series in the chart.</p>\n<p>In ECharts 3, a single echarts instance may contain multiple legend components, which makes it easier for the layout of multiple legend components.</p>\n<p>If there have to be too many legend items, <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=pie-legend&amp;edit=1&amp;reset=1\" target=\"_blank\">vertically scrollable legend</a> or <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=radar2&amp;edit=1&amp;reset=1\" target=\"_blank\">horizontally scrollable legend</a> are options to paginate them. Check <a href=\"#legend.type\">legend.type</a> please.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Type of legend. Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;plain&#39;</code>: Simple legend. (default)</li>\n<li><code class=\"codespan\">&#39;scroll&#39;</code>: Scrollable legend. It helps when too many legend items needed to be shown.</li>\n</ul>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=pie-legend&amp;edit=1&amp;reset=1\" target=\"_blank\">vertically scrollable legend</a> or <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=radar2&amp;edit=1&amp;reset=1\" target=\"_blank\">horizontally scrollable legend</a>.</p>\n<p>When <code class=\"codespan\">&#39;scroll&#39;</code> used, these options below can be used for detailed configuration:</p>\n<ul>\n<li><a href=\"#legend.scrollDataIndex\">legend.scrollDataIndex</a></li>\n<li><a href=\"#legend.pageButtonItemGap\">legend.pageButtonItemGap</a></li>\n<li><a href=\"#legend.pageButtonGap\">legend.pageButtonGap</a></li>\n<li><a href=\"#legend.pageButtonPosition\">legend.pageButtonPosition</a></li>\n<li><a href=\"#legend.pageFormatter\">legend.pageFormatter</a></li>\n<li><a href=\"#legend.pageIcons\">legend.pageIcons</a></li>\n<li><a href=\"#legend.pageIconColor\">legend.pageIconColor</a></li>\n<li><a href=\"#legend.pageIconInactiveColor\">legend.pageIconInactiveColor</a></li>\n<li><a href=\"#legend.pageIconSize\">legend.pageIconSize</a></li>\n<li><a href=\"#legend.pageTextStyle\">legend.pageTextStyle</a></li>\n<li><a href=\"#legend.animation\">legend.animation</a></li>\n<li><a href=\"#legend.animationDurationUpdate\">legend.animationDurationUpdate</a></li>\n</ul>\n","uiControl":{"type":"enum","options":"plain,scroll"}},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"show":{"type":["boolean"],"description":"\n\n\n\n\n\n\n\n","uiControl":{"type":"boolean","default":"true"},"default":true},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between legend component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'auto'"},"top":{"type":["string","number"],"description":"<p>Distance between legend component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'auto'"},"right":{"type":["string","number"],"description":"<p>Distance between legend component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"bottom":{"type":["string","number"],"description":"<p>Distance between legend component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"width":{"type":["string","number"],"description":"<p>Width of legend component. Adaptive by default.</p>\n","default":"'auto'"},"height":{"type":["string","number"],"description":"<p>Height of legend component. Adaptive by default.</p>\n","default":"'auto'"},"orient":{"type":["string"],"description":"\n\n<p>The layout orientation of legend.</p>\n<p>Options:</p>\n<ul>\n<li>&#39;horizontal&#39;</li>\n<li>&#39;vertical&#39;</li>\n</ul>\n","uiControl":{"type":"enum","options":"vertical,horizontal","default":"horizontal"},"default":"'horizontal'"},"align":{"type":["string"],"description":"\n\n<p>Legend marker and text aligning. By default, it automatically calculates from component location and orientation. When <a href=\"#legend.left\">left</a> value of this component is &#39;right&#39;, and the vertical layout (<a href=\"#legend.orient\">orient</a> is &#39;vertical&#39;), it would be aligned to &#39;right&#39;.</p>\n<p>Option:</p>\n<ul>\n<li>&#39;auto&#39;</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n</ul>\n","uiControl":{"type":"enum","options":"auto,left,right","default":"auto"},"default":"'auto'"},"padding":{"type":["number","Array"],"description":"\n\n\n\n\n\n<p>legend space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"itemGap":{"type":["number"],"description":"\n\n<p>The distance between each legend, horizontal distance in horizontal layout, and vertical distance in vertical layout.</p>\n","uiControl":{"type":"number","default":"10","min":"0","step":"0.5"},"default":10},"itemWidth":{"type":["number"],"description":"\n\n<p>Image width of legend symbol.</p>\n","uiControl":{"type":"number","default":"25","min":"0","step":"0.5"},"default":25},"itemHeight":{"type":["number"],"description":"\n\n<p>Image height of legend symbol.</p>\n","uiControl":{"type":"number","default":"14","min":"0","step":"0.5"},"default":14},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for icons (from <code class=\"codespan\">series.symbol</code> or user-defined <code class=\"codespan\">legend.data.icon</code>) in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean"},"default":true},"formatter":{"type":["string","Function"],"description":"<p>Formatter is used to format label of legend, which supports string template and callback function.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// using string template, the template variable is legend name {name}\nformatter: &#39;Legend {name}&#39;\n// using callback function\nformatter: function (name) {\n    return &#39;Legend &#39; + name;\n}\n</code></pre>\n","default":null},"selectedMode":{"type":["string","boolean"],"description":"\n\n<p>Selected mode of legend, which controls whether series can be toggled displaying by clicking legends. It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disable it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selection.</p>\n","uiControl":{"type":"boolean","options":"true,false,single,multiple"},"default":true},"inactiveColor":{"type":["Color"],"description":"\n\n<p>Legend color when not selected.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"selected":{"type":["Object"],"description":"<p>State table of selected legend.</p>\n<p>example:</p>\n<pre><code>selected: {\n    // selected&#39;series 1&#39;\n    &#39;series 1&#39;: true,\n    // unselected&#39;series 2&#39;\n    &#39;series 2&#39;: false\n}\n</code></pre>"},"textStyle":{"type":["Object"],"description":"<p>Legend text style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"#333"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"tooltip":{"type":["Object"],"description":"<p>Tooltip configuration for legend tooltip, which is similar to <a href=\"#tooltip\">tooltip</a>.</p>\n"},"icon":{"type":["string"],"description":"\n\n<p>Icon of the legend items.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon"}},"data":{"type":["Array"],"description":"<p>Data array of legend. An array item is usually a <code class=\"codespan\">name</code> representing string. (If it is a <a href=\"#series-pie\">pie chart</a>, it could also be the <code class=\"codespan\">name</code> of a single data in the pie chart) of a series. Legend component would automatically calculate the color and icon according to series. Special string <code class=\"codespan\">&#39;&#39;</code> (null string) or <code class=\"codespan\">&#39;\\n&#39;</code> (new line string) can be used for a new line.</p>\n<p>If <code class=\"codespan\">data</code> is not specified, it will be auto collected from series. For most of series, it will be collected from <a href=\"#series.name\">series.name</a> or the dimension name specified by <code class=\"codespan\">seriesName</code> of <a href=\"#series.encode\">series.encode</a>. For some types of series like <a href=\"#series-pie\">pie</a> and <a href=\"#series-funnel\">funnel</a>, it will be collected from the name field of <code class=\"codespan\">series.data</code>.</p>\n<p>If you need to set the style for a single item, you may also set the configuration of it. In this case, <code class=\"codespan\">name</code> attribute is used to represent name of <code class=\"codespan\">series</code>.</p>\n<p>Example:</p>\n<pre><code>data: [{\n    name: &#39;series 1&#39;,\n    // compulsorily set icon as a circle\n    icon: &#39;circle&#39;,\n    // set up the text in red\n    textStyle: {\n        color: &#39;red&#39;\n    }\n}]\n</code></pre>","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Name of legend, which should be the <code class=\"codespan\">name</code> value of a certain series. If it is a pie chart, legend name can also be the name of a single data item.</p>\n"},"icon":{"type":["string"],"description":"<p>Icon of the legend.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"textStyle":{"type":["Object"],"description":"<p>Text style of legend.</p>\n"}}}},"backgroundColor":{"type":["Color"],"description":"\n\n<p>Background color of legend, which is transparent by default.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>.</p>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of legend. Support the same color format as backgroundColor.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of legend.</p>\n","uiControl":{"type":"number","default":"1","min":"0","step":"0.5"},"default":1},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>The radius of rounded corner. Its unit is px. And it supports use array to respectively specify the 4 corner radiuses.</p>\n<p>For example:</p>\n<pre><code>borderRadius: 5, // consistently set the size of 4 rounded corners\nborderRadius: [5, 5, 0, 0] // (clockwise upper left, upper right, bottom right and bottom left)\n</code></pre>","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"},"default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n<p><strong>Attention</strong>: This property works only if <code class=\"codespan\">show: true</code> is configured and <code class=\"codespan\">backgroundColor</code> is defined other than <code class=\"codespan\">transparent</code>.</p>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n<p><strong>Attention</strong>: This property works only if <code class=\"codespan\">show: true</code> configured.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n<p><strong>Attention</strong>: This property works only if <code class=\"codespan\">show: true</code> configured.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n<p><strong>Attention</strong>: This property works only if <code class=\"codespan\">show: true</code> configured.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"scrollDataIndex":{"type":["number"],"description":"<p>It works when <a href=\"#legend.type\">legend.type</a> is <code class=\"codespan\">&#39;scroll&#39;</code>.</p>\n<p><code class=\"codespan\">dataIndex</code> of the left top most displayed item.</p>\n<p>Although the scrolling of legend items can be controlled by calling <code class=\"codespan\">setOption</code> and specifying this property, we suggest that do not control legend in this way unless necessary (<code class=\"codespan\">setOption</code> might be time-consuming), but just use action <a href=\"api.html#action.legend.legendScroll\" target=\"_blank\">legendScroll</a> to do that.</p>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=pie-legend&amp;edit=1&amp;reset=1\" target=\"_blank\">vertically scrollable legend</a> or <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=radar2&amp;edit=1&amp;reset=1\" target=\"_blank\">horizontally scrollable legend</a>.</p>\n","default":0},"pageButtonItemGap":{"type":["number"],"description":"<p>It works when <a href=\"#legend.type\">legend.type</a> is <code class=\"codespan\">&#39;scroll&#39;</code>.</p>\n<p>The gap between page buttons and page info text.</p>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=pie-legend&amp;edit=1&amp;reset=1\" target=\"_blank\">vertically scrollable legend</a> or <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=radar2&amp;edit=1&amp;reset=1\" target=\"_blank\">horizontally scrollable legend</a>.</p>\n","default":5},"pageButtonGap":{"type":["number"],"description":"<p>It works when <a href=\"#legend.type\">legend.type</a> is <code class=\"codespan\">&#39;scroll&#39;</code>.</p>\n<p>The gap between page buttons and legend items.</p>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=pie-legend&amp;edit=1&amp;reset=1\" target=\"_blank\">vertically scrollable legend</a> or <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=radar2&amp;edit=1&amp;reset=1\" target=\"_blank\">horizontally scrollable legend</a>.</p>\n","default":null},"pageButtonPosition":{"type":["string"],"description":"<p>It works when <a href=\"#legend.type\">legend.type</a> is <code class=\"codespan\">&#39;scroll&#39;</code>.</p>\n<p>The position of page buttons and page info. Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code>: on the left or top.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code>: on the right or bottom.</li>\n</ul>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=pie-legend&amp;edit=1&amp;reset=1\" target=\"_blank\">vertically scrollable legend</a> or <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=radar2&amp;edit=1&amp;reset=1\" target=\"_blank\">horizontally scrollable legend</a>.</p>\n","default":"'end'"},"pageFormatter":{"type":["string","Function"],"description":"<p>It works when <a href=\"#legend.type\">legend.type</a> is <code class=\"codespan\">&#39;scroll&#39;</code>.</p>\n<p>Page info formatter. It is <code class=\"codespan\">&#39;{current}/{total}&#39;</code> by default, where <code class=\"codespan\">{current}</code> is current page number (start from 1), and <code class=\"codespan\">{total}</code> is the total page number.</p>\n<p>If <code class=\"codespan\">pageFormatter</code> is a function, it should return a string. The parameters is:</p>\n<pre><code class=\"lang-js\">{\n    current: number\n    total: number\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=pie-legend&amp;edit=1&amp;reset=1\" target=\"_blank\">vertically scrollable legend</a> or <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=radar2&amp;edit=1&amp;reset=1\" target=\"_blank\">horizontally scrollable legend</a>.</p>\n","default":"'{current}/{total}'"},"pageIcons":{"type":["Object"],"description":"<p>It works when <a href=\"#legend.type\">legend.type</a> is <code class=\"codespan\">&#39;scroll&#39;</code>.</p>\n<p>The icons of page buttons.</p>\n","properties":{"horizontal":{"type":["Array"],"description":"<p>The icons of page buttons when <a href=\"#legend.orient\">legend.orient</a> is <code class=\"codespan\">&#39;horizontal&#39;</code>.</p>\n<p>It should be an array, <code class=\"codespan\">[previous page button, next page button]</code>, <code class=\"codespan\">[&#39;M0,0L12,-10L12,10z&#39;, &#39;M0,0L-12,-10L-12,10z&#39;]</code> by default.</p>\n<p>For the each item of the array,</p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=pie-legend&amp;edit=1&amp;reset=1\" target=\"_blank\">vertically scrollable legend</a> or <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=radar2&amp;edit=1&amp;reset=1\" target=\"_blank\">horizontally scrollable legend</a>.</p>\n"},"vertical":{"type":["Array"],"description":"<p>The icons of page buttons when <a href=\"#legend.orient\">legend.orient</a> is <code class=\"codespan\">&#39;vertical&#39;</code>.</p>\n<p>It should be an array, <code class=\"codespan\">[previous page button, next page button]</code>, <code class=\"codespan\">[&#39;M0,0L20,0L10,-20z&#39;, &#39;M0,0L20,0L10,20z&#39;]</code> by default.</p>\n<p>For the each item of the array,</p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=pie-legend&amp;edit=1&amp;reset=1\" target=\"_blank\">vertically scrollable legend</a> or <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=radar2&amp;edit=1&amp;reset=1\" target=\"_blank\">horizontally scrollable legend</a>.</p>\n"}}},"pageIconColor":{"type":["string"],"description":"\n\n<p>It works when <a href=\"#legend.type\">legend.type</a> is <code class=\"codespan\">&#39;scroll&#39;</code>.</p>\n<p>The color of page buttons.</p>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=pie-legend&amp;edit=1&amp;reset=1\" target=\"_blank\">vertically scrollable legend</a> or <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=radar2&amp;edit=1&amp;reset=1\" target=\"_blank\">horizontally scrollable legend</a>.</p>\n","uiControl":{"type":"color","default":"#2f4554"},"default":"'#2f4554'"},"pageIconInactiveColor":{"type":["string"],"description":"\n\n<p>It works when <a href=\"#legend.type\">legend.type</a> is <code class=\"codespan\">&#39;scroll&#39;</code>.</p>\n<p>The color of page buttons when they are inactive.</p>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=pie-legend&amp;edit=1&amp;reset=1\" target=\"_blank\">vertically scrollable legend</a> or <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=radar2&amp;edit=1&amp;reset=1\" target=\"_blank\">horizontally scrollable legend</a>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"'#aaa'"},"pageIconSize":{"type":["number","Array"],"description":"\n\n<p>It works when <a href=\"#legend.type\">legend.type</a> is <code class=\"codespan\">&#39;scroll&#39;</code>.</p>\n<p>The size of page buttons. It can be a number, or an array, like <code class=\"codespan\">[10, 3]</code>, represents <code class=\"codespan\">[width, height]</code>.</p>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=pie-legend&amp;edit=1&amp;reset=1\" target=\"_blank\">vertically scrollable legend</a> or <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=radar2&amp;edit=1&amp;reset=1\" target=\"_blank\">horizontally scrollable legend</a>.</p>\n","uiControl":{"type":"vector","default":"15,15","dims":"w,h"},"default":15},"pageTextStyle":{"type":["Object"],"description":"<p>It works when <a href=\"#legend.type\">legend.type</a> is <code class=\"codespan\">&#39;scroll&#39;</code>.</p>\n<p>The text style of page info.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"#333"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to use animation when page scrolls.</p>\n","uiControl":{"type":"boolean","default":"true"}},"animationDurationUpdate":{"type":["number"],"description":"\n\n<p>Duration of the page scroll animation.</p>\n","uiControl":{"type":"number","min":"0","default":"800","step":"20"},"default":800},"emphasis":{"type":["Object"],"description":"","properties":{"selectorLabel":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.4.0</code></p>\n</blockquote>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"selector":{"type":["boolean","Array"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.4.0</code></p>\n</blockquote>\n<p>The selector button in the legend component. Currently includes both a full selection and an inverse selection. The selector button doesn&#39;t display by default, the user can manually configure it.</p>\n<p>Usage:</p>\n<pre><code class=\"lang-js\">selector: [\n    {\n        type: &#39;all or inverse&#39;,\n        // can be any title you like\n        title: &#39;All&#39;\n    },\n    {\n        type: &#39;inverse&#39;,\n        title: &#39;Inv&#39;\n    }\n]\n\n// or\nselector: true\n\n// or\nselector: [&#39;all&#39;, &#39;inverse&#39;]\n</code></pre>\n","default":false},"selectorLabel":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.4.0</code></p>\n</blockquote>\n<p>The text label style of the selector button, which is displayed by default.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"selectorPosition":{"type":["string"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v4.4.0</code></p>\n</blockquote>\n<p>The position of the selector button, which can be placed at the end or start of the legend component, the corresponding values are <code class=\"codespan\">&#39;end&#39;</code> and <code class=\"codespan\">&#39;start&#39;</code>. By default, when the legend is laid out horizontally, the selector is placed at the end of it, and when the legend is laid out vertically, the selector is placed at the start of it.</p>\n","uiControl":{"type":"enum","options":"auto,start,end"},"default":"'auto'"},"selectorItemGap":{"type":["number"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v4.4.0</code></p>\n</blockquote>\n<p>The gap between the selector button.</p>\n","uiControl":{"type":"number","min":"0","default":"7","step":"0.5"},"default":7},"selectorButtonGap":{"type":["number"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v4.4.0</code></p>\n</blockquote>\n<p>The gap between selector button and legend component.</p>\n","uiControl":{"type":"number","min":"0","default":"10","step":"0.5"},"default":10}}},"grid":{"type":["Object"],"description":"<p>Drawing grid in rectangular coordinate. In a single grid, at most two X and Y axes each is allowed. <a href=\"#series-line\">Line chart</a>, <a href=\"#series-bar\">bar chart</a>, and <a href=\"#series-scatter\">scatter chart (bubble chart)</a> can be drawn in grid.</p>\n<p>In ECharts 2.x, there could only be one single grid component at most in a single echarts instance. But in ECharts 3, there is no limitation.</p>\n<p><strong>Following is an example of Anscombe Quartet:</strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-anscombe-quartet&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the grid in rectangular coordinate.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between grid  component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'10%'"},"top":{"type":["string","number"],"description":"<p>Distance between grid  component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":60},"right":{"type":["string","number"],"description":"<p>Distance between grid  component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":"'10%'"},"bottom":{"type":["string","number"],"description":"<p>Distance between grid  component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":60},"width":{"type":["string","number"],"description":"<p>Width of grid  component. Adaptive by default.</p>\n","default":"'auto'"},"height":{"type":["string","number"],"description":"<p>Height of grid  component. Adaptive by default.</p>\n","default":"'auto'"},"containLabel":{"type":["boolean"],"description":"\n\n<p>Whether the grid region contains <a href=\"#yAxis.axisLabel\">axis tick label</a> of axis.</p>\n<ul>\n<li>When containLabel is <code class=\"codespan\">false</code>:<ul>\n<li><code class=\"codespan\">grid.left</code> <code class=\"codespan\">grid.right</code> <code class=\"codespan\">grid.top</code> <code class=\"codespan\">grid.bottom</code> <code class=\"codespan\">grid.width</code> <code class=\"codespan\">grid.height</code> decide the location and size of the rectangle that is made of by xAxis and yAxis.</li>\n<li>Setting to <code class=\"codespan\">false</code> will help when multiple grids need to be aligned at their axes.</li>\n</ul>\n</li>\n<li>When containLabel is <code class=\"codespan\">true</code>:<ul>\n<li><code class=\"codespan\">grid.left</code> <code class=\"codespan\">grid.right</code> <code class=\"codespan\">grid.top</code> <code class=\"codespan\">grid.bottom</code> <code class=\"codespan\">grid.width</code> <code class=\"codespan\">grid.height</code> decide the location and size of the rectangle that contains the axes and the labels of the axes.</li>\n<li>Setting to <code class=\"codespan\">true</code> will help when the length of axis labels is dynamic and is hard to approximate. This will avoid labels from overflowing the container or overlapping other components.</li>\n</ul>\n</li>\n</ul>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"backgroundColor":{"type":["Color"],"description":"\n\n<p>Background color of grid, which is transparent by default.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>.</p>\n</blockquote>\n<p><strong>Attention</strong>: Works only if <code class=\"codespan\">show: true</code> is set.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of grid. Support the same color format as backgroundColor.</p>\n<p><strong>Attention</strong>: Works only if <code class=\"codespan\">show: true</code> is set.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of grid.</p>\n<p><strong>Attention</strong>: Works only if <code class=\"codespan\">show: true</code> is set.</p>\n","uiControl":{"type":"number","default":"1","min":"0","step":"0.5"},"default":1},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n<p><strong>Attention</strong>: This property works only if <code class=\"codespan\">show: true</code> is configured and <code class=\"codespan\">backgroundColor</code> is defined other than <code class=\"codespan\">transparent</code>.</p>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n<p><strong>Attention</strong>: This property works only if <code class=\"codespan\">show: true</code> configured.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n<p><strong>Attention</strong>: This property works only if <code class=\"codespan\">show: true</code> configured.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n<p><strong>Attention</strong>: This property works only if <code class=\"codespan\">show: true</code> configured.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"tooltip":{"type":["Object"],"description":"<p>tooltip settings in the coordinate system component.</p>\n<hr>\n<p><strong>General Introduction:</strong></p>\n<p>tooltip can be configured on different places:</p>\n<ul>\n<li><p>Configured on global: <a href=\"#tooltip\">tooltip</a></p>\n</li>\n<li><p>Configured in a coordinate system: <a href=\"#grid.tooltip\">grid.tooltip</a>, <a href=\"#polar.tooltip\">polar.tooltip</a>, <a href=\"#single.tooltip\">single.tooltip</a></p>\n</li>\n<li><p>Configured in a series: <a href=\"#series.tooltip\">series.tooltip</a></p>\n</li>\n<li><p>Configured in each item of <code class=\"codespan\">series.data</code>: <a href=\"#series.data.tooltip\">series.data.tooltip</a></p>\n</li>\n</ul>\n<hr>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the tooltip component, including tooltip floating layer and <a href=\"#tooltip.axisPointer\">axisPointer</a>.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"trigger":{"type":["string"],"description":"\n\n<p>Type of triggering.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;item&#39;</code></p>\n<p>  Triggered by data item, which is mainly used for charts that don&#39;t have a category axis like scatter charts or pie charts.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;axis&#39;</code></p>\n<p>  Triggered by axes, which is mainly used for charts that have category axes, like bar charts or line charts.</p>\n<p> ECharts 2.x only supports axis trigger for category axis. In ECharts 3, it is supported for all types of axes in <a href=\"#grid\">grid</a> or <a href=\"#polar\">polar</a>. Also, you may assign axis with <a href=\"#tooltip.axisPointer.axis\">axisPointer.axis</a>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code></p>\n<p>  Trigger nothing.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"item,axis,none","default":"item"},"default":"'item'"},"axisPointer":{"type":["Object"],"description":"<p>Configuration item for axisPointer.</p>\n<p><code class=\"codespan\">tooltip.axisPointer</code> is like syntactic sugar of axisPointer settings on axes (for example, <a href=\"#xAxis.axisPointer\">xAxis.axisPointer</a> or <a href=\"#angleAxis.axisPointer\">angleAxis.axisPointer</a>). More detailed features can be configured on <code class=\"codespan\">someAxis.axisPointer</code>. But in common cases, using <code class=\"codespan\">tooltip.axisPointer</code> is more convenient.</p>\n<blockquote>\n<p><strong>Notice:</strong> configurations of <code class=\"codespan\">tooltip.axisPointer</code> has lower priority than that of <code class=\"codespan\">someAxis.axisPointer</code>.</p>\n</blockquote>\n<hr>\n<p><code class=\"codespan\">axisPointer</code> is a tool for displaying reference line and axis value under mouse pointer.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/candlestick-axisPointer&edit=1&reset=1\" width=\"600\" height=\"450\"></iframe>\n\n\n<p>In the demo above, <a href=\"#axisPointer.link\">axisPointer.link</a> is used to link axisPointer from different coordinate systems.</p>\n<p><code class=\"codespan\">axisPointer</code> can also be used on touch device, where user can drag the button to move the reference line and label.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-tooltip-touch&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n<p>In the cases that more than one axis exist, axisPointer helps to look inside the data.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=multiple-y-axis&edit=1&reset=1\" width=\"600\" height=\"300\"></iframe>\n\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=multiple-x-axis&edit=1&reset=1\" width=\"600\" height=\"300\"></iframe>\n\n\n\n<hr>\n<blockquote>\n<p><strong>Notice:</strong>\nGenerally, axisPointers is configured in each axes who need them (for example <a href=\"#xAxis.axisPointer\">xAxis.axisPointer</a>), or configured in <code class=\"codespan\">tooltip</code> (for example <a href=\"#tooltip.axisPointer\">tooltip.axisPointer</a>).</p>\n</blockquote>\n<blockquote>\n<p>But these configurations can only be configured in global axisPointer:\n<a href=\"#axisPointer.triggerOn\">axisPointer.triggerOn</a>, <a href=\"#axisPointer.link\">axisPointer.link</a>.</p>\n</blockquote>\n<hr>\n<hr>\n<p><strong>How to display axisPointer:</strong></p>\n<p>In <a href=\"#grid\">cartesian (grid)</a> and <a href=\"#single\">polar](~polar) and (single axis</a>, each axis has its own axisPointer.</p>\n<p>Those axisPointer will not be displayed by default, utill configured as follows:</p>\n<ul>\n<li><p>Set <code class=\"codespan\">someAxis.axisPointer.show</code> (like <a href=\"#xAxis.axisPointer.show\">xAxis.axisPointer.show</a>) as <code class=\"codespan\">true</code>. Then axisPointer of this axis will be displayed.</p>\n</li>\n<li><p>Set <a href=\"#tooltip.trigger\">tooltip.trigger</a> as <code class=\"codespan\">&#39;axis&#39;</code>, or set <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> as <code class=\"codespan\">&#39;cross&#39;</code>. Then coordinate system will automatically chose the axes who will display their axisPointers. (<a href=\"#tooltip.axisPointer.axis\">tooltip.axisPointer.axis</a> can be used to change the choice.) Notice, <code class=\"codespan\">axis.axisPointer</code> will override <code class=\"codespan\">tooltip.axisPointer</code> settings.</p>\n</li>\n</ul>\n<hr>\n<p><strong>How to display the label of axisPointer:</strong></p>\n<p>The label of axisPointer will not be displayed by default(namely, only reference line will be displayed by default), utill configured as follows:</p>\n<ul>\n<li><p>Set <code class=\"codespan\">someAxis.axisPointer.label.show</code> (for example <a href=\"#xAxis.axisPointer.show\">xAxis.axisPointer.label.show</a>) as <code class=\"codespan\">true</code>. Then the label of the axisPointer will be displayed.</p>\n</li>\n<li><p>Set <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> as  <code class=\"codespan\">&#39;cross&#39;</code>. Then the label of the crossed axisPointers will be displayed.</p>\n</li>\n</ul>\n<hr>\n<p><strong>How to configure axisPointer on touch device:</strong></p>\n<p>Set <code class=\"codespan\">someAxis.axisPointer.handle.show</code> (for example <a href=\"#xAxis.axisPointer.handle.show\">xAxis.axisPointer.handle.show</a> as <code class=\"codespan\">true</code>. Then the button for dragging will be displayed. (This feature is not supported on polar).</p>\n<p><strong>Notice:</strong>\nIf tooltip does not work well in this case, try to set<a href=\"#tooltip.triggerOn\">tooltip.triggerOn</a> as <code class=\"codespan\">&#39;none&#39;</code> (for the effect: show tooltip when finger holding on the button, and hide tooltip after finger left the button), or set <a href=\"#tooltip.alwaysShowContent\">tooltip.alwaysShowContent</a> as <code class=\"codespan\">true</code> (then tooltip will always be displayed).</p>\n<p>See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-tooltip-touch&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>.</p>\n<hr>\n<p><strong>Snap to point</strong></p>\n<p>In value axis and time axis, if <a href=\"#xAxis.axisPointer.snap\">snap</a> is set as true, axisPointer will snap to point automatically.</p>\n<hr>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Indicator type.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;line&#39;</code> line indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;shadow&#39;</code> shadow crosshair indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code> no indicator displayed.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;cross&#39;</code> crosshair indicator, which is actually the shortcut of enable two axisPointers of two orthometric axes.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"none,line,shadow,cross","default":"line"},"default":"'line'"},"axis":{"type":["string"],"description":"<p>The coordinate axis, which could be <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, <code class=\"codespan\">&#39;radius&#39;</code>, or <code class=\"codespan\">&#39;angle&#39;</code>. By default, each coordinate system will automatically chose the axes whose will display its axisPointer (category axis or time axis is used by default).</p>\n","default":"'auto'"},"snap":{"type":["boolean"],"description":"<p>Whether snap to point automatically. The default value is auto determined.</p>\n<p>This feature usually makes sense in value axis and time axis, where tiny points can be seeked automatically.</p>\n"},"z":{"type":["number"],"description":"<p>z value, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n"},"label":{"type":["Object"],"description":"<p>label of axisPointer</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label. Label will not show by default. But if <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, label will be displayed automatically.</p>\n","default":false},"precision":{"type":["number","string"],"description":"<p>The precision of value in label. It is auto determined by default. You can also set it as <code class=\"codespan\">&#39;2&#39;</code>, which indicates that two decimal fractions are reserved.</p>\n","default":"'auto'"},"formatter":{"type":["string","Function"],"description":"<p>The formatter of label.</p>\n<p>If set as <code class=\"codespan\">string</code>, for example it can be: <code class=\"codespan\">formatter: &#39;some text {value} some text</code>, where <code class=\"codespan\">{value}</code> will be replaced by axis value automatically.</p>\n<p>If set as <code class=\"codespan\">function</code>:</p>\n<p><strong>Parameters:</strong></p>\n<p><code class=\"codespan\">{Object}</code> params: Including fields as follows:</p>\n<p><code class=\"codespan\">{Object}</code> params.value: current value of this axis. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;category&#39;</code>, it is one of the value in <code class=\"codespan\">axis.data</code>. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;time&#39;</code>, it is a timestamp.</p>\n<p><code class=\"codespan\">{Array.&lt;Object&gt;}</code> params.seriesData: An array, containing info of nearest points. Each item is:</p>\n<p><code class=\"codespan\">{string}</code> params.axisDimension: The dimension name of the axis. For example, in catesian it will be <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, and in polar it will be <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code>.</p>\n<p><code class=\"codespan\">{number}</code> params.axisIndex: The index of the axis, for example, <code class=\"codespan\">0</code>,<code class=\"codespan\">1</code>, <code class=\"codespan\">2</code>, ...</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>Each item also includes axis infomation:</p>\n<pre><code class=\"lang-js\">{\n    axisDim: &#39;x&#39;, // &#39;x&#39;, &#39;y&#39;, &#39;angle&#39;, &#39;radius&#39;, &#39;single&#39;\n    axisId: &#39;xxx&#39;,\n    axisName: &#39;xxx&#39;,\n    axisIndex: 3,\n    axisValue: 121, // The current value of axisPointer\n    axisValueLabel: &#39;text of value&#39;\n}\n</code></pre>\n<p><strong>Return:</strong></p>\n<p>The string to be displayed.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">formatter: function (params) {\n    // If axis.type is &#39;time&#39;\n    return &#39;some text&#39; + echarts.format.formatTime(params.value);\n}\n</code></pre>\n","default":null},"margin":{"type":["boolean"],"description":"<p>Distance between label and axis.</p>\n","default":3},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"padding":{"type":["string","Array"],"description":"\n\n<p>axisPointer space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":"[5, 7, 5, 7]"},"backgroundColor":{"type":["string"],"description":"<p>Background color of label, the same as <a href=\"#xAxis.axisLine.lineStyle.color\">axis.axisLine.lineStyle.color</a> by default.</p>\n","default":"'auto'"},"borderColor":{"type":["string"],"description":"<p>Border color of label.</p>\n","default":null},"borderWidth":{"type":["string"],"description":"<p>Border width of label.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"lineStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;line&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#555"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"shadowStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;shadow&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'rgba(150,150,150,0.3)"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"crossStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;cross&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#555"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"dashed"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":200},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"exponentialOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"position":{"type":["string","Array"],"description":"<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n\n\n\n\n\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n\n\n\n\n\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n\n\n\n\n\n\n\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},"xAxis":{"type":["Object"],"description":"<p>The x axis in cartesian(rectangular) coordinate. Usually a single grid component can place at most 2 x axis, one on the bottom and another on the top. <a href=\"#xAxis.offset\">offset</a> can be used to avoid overlap when you need to put more than two x axis.</p>\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"gridIndex":{"type":["number"],"description":"<p>The index of grid which the x axis belongs to. Defaults to be in the first grid.</p>\n","default":0},"position":{"type":["string"],"description":"\n\n<p>The position of x axis.</p>\n<p>options:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>The first x axis in grid defaults to be on the bottom of the grid, and the second x axis is on the other side against the first x axis.</p>\n","uiControl":{"type":"enum","options":"top,bottom","default":"bottom"}},"offset":{"type":["number"],"description":"\n\n<p>Offset of x axis relative to default position. Useful when multiple x axis has same <a href=\"#xAxis.position\">position</a> value.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"realtimeSort":{"type":["*"],"description":"<p><code class=\"codespan\">realtimeSort</code> is used to enable bar race if set to be <code class=\"codespan\">true</code>. It is only valid if the <a href=\"#xAxis.type\">type</a> of xAxis is <code class=\"codespan\">&#39;value&#39;</code>.</p>\n<p>It should be used along with other options to enable bar race. Please refer to <a href=\"tutorial.html#Bar%20Race\" target=\"_blank\">bar race</a> tutorial for more details.</p>\n","default":false},"sortSeriesIndex":{"type":["*"],"description":"<p>The index of series used to sort in bar race. Since only one series is supported in bar race, <code class=\"codespan\">sortSeriesIndex</code> should always be <code class=\"codespan\">0</code>. It is only valid if <a href=\"#xAxis.realtimeSort\">realtimeSort</a> is <code class=\"codespan\">true</code> and <a href=\"#xAxis.type\">type</a> is <code class=\"codespan\">&#39;value&#39;</code>.</p>\n<p>It should be used along with other options to enable bar race. Please refer to <a href=\"tutorial.html#Bar%20Race\" target=\"_blank\">bar race</a> tutorial for more details.</p>\n","default":0},"type":{"type":["string"],"description":"<p>Type of axis.</p>\n<p>Option:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;value&#39;</code>\n  Numerical axis, suitable for continuous data.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;category&#39;</code>\n  Category axis, suitable for discrete category data. Category data can be auto retrieved from <a href=\"#series.data\">series.data</a> or <a href=\"#dataset.source\">dataset.source</a>, or can be specified via <a href=\"#xAxis.data\">xAxis.data</a>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;time&#39;</code>\n  Time axis, suitable for continuous time series data. As compared to value axis, it has a better formatting for time and a different tick calculation method. For example, it decides to use month, week, day or hour for tick based on the range of span.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;log&#39;</code>\n  Log axis, suitable for log data.</p>\n</li>\n</ul>\n","default":"'category'"},"name":{"type":["string"],"description":"\n\n<p>Name of axis.</p>\n","uiControl":{"type":"text"}},"nameLocation":{"type":["string"],"description":"\n\n<p>Location of axis name.</p>\n<p><strong>Options: </strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> or <code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","options":"start,middle,end","default":"end"},"default":"'end'"},"nameTextStyle":{"type":["Object"],"description":"<p>Text style of axis name.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Color of axis name uses <a href=\"#xAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default.</p>\n","uiControl":{"type":"color"}},"fontStyle":{"type":["string"],"description":"\n\n<p>axis name font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p>axis name font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p>axis name font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p>axis name font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"nameGap":{"type":["number"],"description":"\n\n<p>Gap between axis name and axis line.</p>\n","uiControl":{"type":"number","step":"0.5","default":"15"},"default":15},"nameRotate":{"type":["number"],"description":"\n\n<p>Rotation of axis name.</p>\n","uiControl":{"type":"angle","min":"-360","max":"360","step":"1"},"default":null},"inverse":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> to invert the axis.\nThis is a new option available from Echarts 3 and newer.</p>\n","uiControl":{"type":"boolean"},"default":false},"boundaryGap":{"type":["boolean","Array"],"description":"\n\n<p>The boundary gap on both sides of a coordinate axis. The setting and behavior of category axes and non-category axes are different.</p>\n<p>The <code class=\"codespan\">boundaryGap</code> of category axis can be set to either <code class=\"codespan\">true</code> or <code class=\"codespan\">false</code>. Default value is set to be <code class=\"codespan\">true</code>, in which case <a href=\"#xAxis.axisTick\">axisTick</a> is served only as a separation line, and labels and data appear only in the center part of two <a href=\"#xAxis.axisTick\">axis ticks</a>, which is called <em>band</em>.</p>\n<p>For non-category axis, including time, numerical value, and log axes, <code class=\"codespan\">boundaryGap</code> is an array of two values, representing the spanning range between minimum and maximum value. The value can be set in numeric value or relative percentage, which becomes invalid after setting <a href=\"#xAxis.min\">min</a> and <a href=\"#xAxis.max\">max</a>.\n<strong>Example: </strong></p>\n<pre><code class=\"lang-js\">boundaryGap: [&#39;20%&#39;, &#39;20%&#39;]\n</code></pre>\n","uiControl":{"type":"boolean"}},"min":{"type":["number","string","Function"],"description":"\n\n<p>The minimun value of axis.</p>\n<p>It can be set to a special value <code class=\"codespan\">&#39;dataMin&#39;</code> so that the minimum value on this axis is set to be the minimum label.</p>\n<p>It will be automatically computed to make sure axis tick is equally distributed when not set.</p>\n<p>In category axis, it can also be set as the ordinal number. For example, if a catergory axis has <code class=\"codespan\">data: [&#39;categoryA&#39;, &#39;categoryB&#39;, &#39;categoryC&#39;]</code>, and the ordinal <code class=\"codespan\">2</code> represents <code class=\"codespan\">&#39;categoryC&#39;</code>. Moreover, it can be set as negative number, like <code class=\"codespan\">-3</code>.</p>\n<p>If <code class=\"codespan\">min</code> is specified as a function, it should return a min value, like:</p>\n<pre><code class=\"lang-js\">min: function (value) {\n    return value.min - 20;\n}\n</code></pre>\n<p><code class=\"codespan\">value</code> is an object, containing the <code class=\"codespan\">min</code> value and <code class=\"codespan\">max</code> value of the data. This function should return the min value of axis, or return <code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> to make echarts use the auto calculated min value (<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> return is only supported since <code class=\"codespan\">v4.8.0</code>).</p>\n","uiControl":{"type":"number"},"default":null},"max":{"type":["number","string","Function"],"description":"\n\n<p>The maximum value of axis.</p>\n<p>It can be set to a special value <code class=\"codespan\">&#39;dataMax&#39;</code> so that the minimum value on this axis is set to be the maximum label.</p>\n<p>It will be automatically computed to make sure axis tick is equally distributed when not set.</p>\n<p>In category axis, it can also be set as the ordinal number. For example, if a catergory axis has <code class=\"codespan\">data: [&#39;categoryA&#39;, &#39;categoryB&#39;, &#39;categoryC&#39;]</code>, and the ordinal <code class=\"codespan\">2</code> represents <code class=\"codespan\">&#39;categoryC&#39;</code>. Moreover, it can be set as negative number, like <code class=\"codespan\">-3</code>.</p>\n<p>If <code class=\"codespan\">max</code> is specified as a function, it should return a max value, like:</p>\n<pre><code class=\"lang-js\">max: function (value) {\n    return value.max - 20;\n}\n</code></pre>\n<p><code class=\"codespan\">value</code> is an object, containing the <code class=\"codespan\">min</code> value and <code class=\"codespan\">max</code> value of the data. This function should return the max value of axis, or return <code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> to make echarts use the auto calculated max value (<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> return is only supported since <code class=\"codespan\">v4.8.0</code>).</p>\n","uiControl":{"type":"number"},"default":null},"scale":{"type":["boolean"],"description":"\n\n<p>It is available only in numerical axis, i.e., <a href=\"#xAxis.type\">type</a>: &#39;value&#39;.</p>\n<p>It specifies whether not to contain zero position of axis compulsively. When it is set to be <code class=\"codespan\">true</code>, the axis may not contain zero position, which is useful in the scatter chart for both value axes.</p>\n<p>This configuration item is unavailable when the <a href=\"#xAxis.min\">min</a> and <a href=\"#xAxis.max\">max</a> are set.</p>\n","uiControl":{"type":"boolean"},"default":false},"splitNumber":{"type":["number"],"description":"\n\n<p>Number of segments that the axis is split into. Note that this number serves only as a recommendation, and the true segments may be adjusted based on readability.</p>\n<p>This is unavailable for category axis.</p>\n","uiControl":{"type":"number","min":"1","step":"1","default":"5"},"default":5},"minInterval":{"type":["number"],"description":"\n\n<p>Minimum gap between split lines.</p>\n<p>For example, it can be set to be <code class=\"codespan\">1</code> to make sure axis label is show as integer.</p>\n<pre><code class=\"lang-js\">{\n    minInterval: 1\n}\n</code></pre>\n<p>It is available only for axis of <a href=\"#xAxis.type\">type</a> &#39;value&#39; or &#39;time&#39;.</p>\n","uiControl":{"type":"number"},"default":0},"maxInterval":{"type":["number"],"description":"\n\n<p>Maximum gap between split lines.</p>\n<p>For example, in time axis (<a href=\"#xAxis.type\">type</a> is &#39;time&#39;), it can be set to be <code class=\"codespan\">3600 * 24 * 1000</code> to make sure that the gap between axis labels is less than or equal to one day.</p>\n<pre><code class=\"lang-js\">{\n    maxInterval: 3600 * 1000 * 24\n}\n</code></pre>\n<p>It is available only for axis of <a href=\"#xAxis.type\">type</a> &#39;value&#39; or &#39;time&#39;.</p>\n","uiControl":{"type":"number"}},"interval":{"type":["number"],"description":"\n\n<p>Compulsively set segmentation interval for axis.</p>\n<p>As <a href=\"#xAxis.splitNumber\">splitNumber</a> is a recommendation value, the calculated tick may not be the same as expected. In this case, interval should be used along with <a href=\"#xAxis.min\">min</a> and <a href=\"#xAxis.max\">max</a> to compulsively set tickings. But in most cases, we do not suggest using this, out automatic calculation is enough for most situations.</p>\n<p>This is unavailable for category axis. Timestamp should be passed for <a href=\"#xAxis.type\">type</a>: &#39;time&#39; axis. Logged value should be passed for <a href=\"#xAxis.type\">type</a>: &#39;log&#39; axis.</p>\n","uiControl":{"type":"number"}},"logBase":{"type":["number"],"description":"\n\n<p>Base of logarithm, which is valid only for numeric axes with <a href=\"#xAxis.type\">type</a>: &#39;log&#39;.</p>\n","uiControl":{"type":"number","default":"10"},"default":10},"silent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code>, to prevent interaction with the axis.</p>\n","default":false},"triggerEvent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code> to enable triggering events.</p>\n<p>Parameters of the event include:</p>\n<pre><code class=\"lang-js\">{\n    // Component type: xAxis, yAxis, radiusAxis, angleAxis\n    // Each of which has an attribute for index, e.g., xAxisIndex for xAxis\n    componentType: string,\n    // Value on axis before being formatted.\n    // Click on value label to trigger event.\n    value: &#39;&#39;,\n    // Name of axis.\n    // Click on laben name to trigger event.\n    name: &#39;&#39;\n}\n</code></pre>\n","default":false},"axisLine":{"type":["Object"],"description":"<p>Settings related to axis line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis line from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"onZero":{"type":["boolean"],"description":"\n\n<p>Specifies whether X or Y axis lies on the other&#39;s origin position, where value is 0 on axis. Valid only if the other axis is of value type, and contains 0 value.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"onZeroAxisIndex":{"type":["number"],"description":"<p>When mutiple axes exists, this option can be used to specify which axis can be &quot;onZero&quot; to.</p>\n"},"symbol":{"type":["string","Array"],"description":"\n\n<p>Symbol of the two ends of the axis. It could be a string, representing the same symbol for two ends; or an array with two string elements, representing the two ends separately. It&#39;s set to be <code class=\"codespan\">&#39;none&#39;</code> by default, meaning no arrow for either end. If it is set to be <code class=\"codespan\">&#39;arrow&#39;</code>, there shall be two arrows. If there should only one arrow at the end, it should set to be <code class=\"codespan\">[&#39;none&#39;, &#39;arrow&#39;]</code>.</p>\n","uiControl":{"type":"icon","default":"none"},"default":"'none'"},"symbolSize":{"type":["Array"],"description":"\n\n<p>Size of the arrows at two ends. The first is the width perpendicular to the axis, the next is the width parallel to the axis.</p>\n","uiControl":{"type":"vector","default":"10,15"},"default":"[10, 15]"},"symbolOffset":{"type":["Array","number"],"description":"\n\n<p>Arrow offset of axis. If is array, the first number is the offset of the arrow at the beginning, and the second number is the offset of the arrow at the end. If is number, it means the arrows have the same offset.</p>\n","uiControl":{"type":"vector","default":"0,0"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>line styleLine color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#333'"},"width":{"type":["number"],"description":"\n\n<p>line style line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>line style line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisTick":{"type":["Object"],"description":"<p>Settings related to axis tick.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis tick from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"alignWithLabel":{"type":["boolean"],"description":"\n\n<p>Align axis tick with label, which is available only when <code class=\"codespan\">boundaryGap</code> is set to be <code class=\"codespan\">true</code> in category axis. See the following picture:</p>\n<p><img width=\"600\" height=\"auto\" src=\"documents/asset/img/axis-align-with-label.png\"></p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of axisTick, which is available in category axis.  is set to be the same as <a href=\"#xAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"inside":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> so the axis labels face the <code class=\"codespan\">inside</code> direction.</p>\n","uiControl":{"type":"boolean"},"default":false},"length":{"type":["number"],"description":"\n\n<p>The length of the axis tick.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"5"},"default":5},"lineStyle":{"type":["Object"],"description":"<p>Line style of axis ticks.</p>\n","properties":{"color":{"type":["Color"],"description":"<p>Color of axis label is set to be <a href=\"#xAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default.</p>\n"},"width":{"type":["number"],"description":"\n\n<p>axisTick line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>axisTick line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"minorTick":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.6.0</code></p>\n</blockquote>\n<p>Settings related minor ticks.</p>\n<p>Note: <code class=\"codespan\">minorTick</code> is not available in the <code class=\"codespan\">category</code> type axis.</p>\n<p>Examples:</p>\n<p>1) Using minor ticks in function plotting.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-function&edit=1&reset=1\" width=\"600\" height=\"350\"></iframe>\n\n\n<p>2) Using minor ticks in log axis.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-log&edit=1&reset=1\" width=\"600\" height=\"350\"></iframe>\n\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>If show minor ticks.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"splitNumber":{"type":["number"],"description":"\n\n<p>Number of interval splited by minor ticks.</p>\n","uiControl":{"type":"number","min":"1","step":"1","default":"5"},"default":5},"length":{"type":["number"],"description":"\n\n<p>Length of minor ticks lines。</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"3"},"default":3},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Style configuration of minor ticks lines <a href=\"#xAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a>。</p>\n","uiControl":{"type":"color"}},"width":{"type":["number"],"description":"\n\n<p>minorTick line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>minorTick line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisLabel":{"type":["Object"],"description":"<p>Settings related to axis label.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis label from appearing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis label, which is available in category axis. </p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"inside":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> so the axis labels face the <code class=\"codespan\">inside</code> direction.</p>\n","uiControl":{"type":"boolean"},"default":false},"rotate":{"type":["number"],"description":"\n\n<p>Rotation degree of axis label, which is especially useful when there is no enough space for category axis.</p>\n<p>Rotation degree is from -90 to 90.</p>\n","uiControl":{"type":"angle","min":"-90","max":"90","step":"1"},"default":0},"margin":{"type":["number"],"description":"\n\n<p>The margin between the axis label and the axis line.</p>\n","uiControl":{"type":"number","default":"8","step":"0.5"},"default":8},"formatter":{"type":["string","Function"],"description":"<p>Formatter of axis label, which supports string template and callback function.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use string template; template variable is the default label of axis {value}\nformatter: &#39;{value} kg&#39;\n// Use callback.\nformatter: function (value, index) {\n    return value + &#39;kg&#39;;\n}\n</code></pre>\n<hr>\n<p>For axes of time <a href=\"#.type\">type</a>: <code class=\"codespan\">&#39;time&#39;</code>, <code class=\"codespan\">formatter</code> supports the following forms:</p>\n<ul>\n<li><strong>String Templates</strong>: an easy and fast way to make frequently used date/time template, formed in <code class=\"codespan\">string</code></li>\n<li><strong>Callback Functions</strong>: customized formatter to make complex format, formed in <code class=\"codespan\">Function</code></li>\n<li><strong>Cascading Templates</strong>: to adopt different formatters for different time granularity, formed in <code class=\"codespan\">object</code></li>\n</ul>\n<p>Next, we are going to introduce these three forms one by one.</p>\n<p><strong> String Templates </strong></p>\n<p>Using string templates is an easy way to format date/time with frequently used formats. If it can be used to make what you want, you are advised to do so. If not, you could then consider the others. Supported formats are:</p>\n<table>\n<thead>\n<tr>\n<th>Group</th>\n<th>Template</th>\n<th>Value (EN)</th>\n<th>Value (ZH)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Year</td>\n<td>{yyyy}</td>\n<td>e.g., 2020, 2021, ...</td>\n<td>例：2020, 2021, ...</td>\n</tr>\n<tr>\n<td></td>\n<td>{yy}</td>\n<td>00-99</td>\n<td>00-99</td>\n</tr>\n<tr>\n<td>Quarter</td>\n<td>{Q}</td>\n<td>1, 2, 3, 4</td>\n<td>1, 2, 3, 4</td>\n</tr>\n<tr>\n<td>Month</td>\n<td>{MMMM}</td>\n<td>e.g., January, February, ...</td>\n<td>一月、二月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MMM}</td>\n<td>e.g., Jan, Feb, ...</td>\n<td>1月、2月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MM}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{M}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Day of Month</td>\n<td>{dd}</td>\n<td>01-31</td>\n<td>01-31</td>\n</tr>\n<tr>\n<td></td>\n<td>{d}</td>\n<td>1-31</td>\n<td>1-31</td>\n</tr>\n<tr>\n<td>Day of Week</td>\n<td>{eeee}</td>\n<td>Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday</td>\n<td>星期日、星期一、星期二、星期三、星期四、星期五、星期六</td>\n</tr>\n<tr>\n<td></td>\n<td>{ee}</td>\n<td>Sun, Mon, Tues, Wed, Thu, Fri, Sat</td>\n<td>日、一、二、三、四、五、六</td>\n</tr>\n<tr>\n<td></td>\n<td>{e}</td>\n<td>1-54</td>\n<td>1-54</td>\n</tr>\n<tr>\n<td>Hour</td>\n<td>{HH}</td>\n<td>00-23</td>\n<td>00-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{H}</td>\n<td>0-23</td>\n<td>0-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{hh}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{h}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Minute</td>\n<td>{mm}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{m}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Second</td>\n<td>{ss}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{s}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Millisecond</td>\n<td>{SSS}</td>\n<td>000-999</td>\n<td>000-999</td>\n</tr>\n<tr>\n<td></td>\n<td>{S}</td>\n<td>0-999</td>\n<td>0-999</td>\n</tr>\n</tbody>\n</table>\n<blockquote>\n<p>Templates of other languages can be found in <a href=\"https://github.com/apache/echarts/tree/master/src/i18n\" target=\"_blank\">the language package</a>. Please refer to <a href=\"api.html#echarts.registerLocale\" target=\"_blank\">echarts.registerLocale</a> to register a language.</p>\n</blockquote>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: &#39;{yyyy}-{MM}-{dd}&#39; // gets labels like &#39;2020-12-02&#39;\nformatter: &#39;Day {d}&#39; // gets labels like &#39;Day 2&#39;\n</code></pre>\n<p><strong> Callback Functions </strong></p>\n<p>Callback functions can be used to get different formats for different axis tick values. Sometimes, if you have complex date/time formatting requirement, third-party libraries like <a href=\"https://momentjs.com/\" target=\"_blank\">Moment.js</a> or <a href=\"https://date-fns.org/\" target=\"_blank\">date-fns</a> can be used to return formatted labels.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use callback function; function parameters are axis index\nformatter: function (value, index) {\n    // Formatted to be month/day; display year only in the first label\n    var date = new Date(value);\n    var texts = [(date.getMonth() + 1), date.getDate()];\n    if (idx === 0) {\n        texts.unshift(date.getYear());\n    }\n    return texts.join(&#39;/&#39;);\n}\n</code></pre>\n<p><strong> Cascading Templates </strong></p>\n<p>Sometimes, we wish to use different formats for different time granularity. For example, in a quarter-year chart, we may wish to see the month name with the first date of the month, while see the date name with others. This can be made with:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: {\n    month: &#39;{MMMM}&#39;, // Jan, Feb, ...\n    day: &#39;{d}&#39; // 1, 2, ...\n}\n</code></pre>\n<p>Supported levels and their default formatters are:</p>\n<pre><code class=\"lang-js\">{\n    year: &#39;{yyyy}&#39;,\n    month: &#39;{MMM}&#39;,\n    day: &#39;{d}&#39;,\n    hour: &#39;{HH}:{mm}&#39;,\n    minute: &#39;{HH}:{mm}&#39;,\n    second: &#39;{HH}:{mm}:{ss}&#39;,\n    millisecond: &#39;{hh}:{mm}:{ss} {SSS}&#39;,\n    none: &#39;{yyyy}-{MM}-{dd} {hh}:{mm}:{ss} {SSS}&#39;\n}\n</code></pre>\n<p>Let&#39;s take <code class=\"codespan\">day</code> for example. When a tick value is <code class=\"codespan\">0</code> for its hour, minute, second, and millisecond, <code class=\"codespan\">day</code> level will be used to make formatter. <code class=\"codespan\">none</code> is used when no other level fulfills, which is for tick values with millisecond values other than <code class=\"codespan\">0</code>.</p>\n<p><strong> Rich Text </strong></p>\n<p>The above three forms all support rich text, so it can be used to make some complex effects.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: {\n            // Display year and month information on the first data of a year\n            year: &#39;{yearStyle|{yyyy}}\\n{monthStyle|{MMM}}&#39;,\n            month: &#39;{monthStyle|{MMM}}&#39;\n        },\n        rich: {\n            yearStyle: {\n                // Make yearly text more standing out\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            monthStyle: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n<p>The above example can also be made with a callback function:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: function (value) {\n            const date = new Date(value);\n            const yearStart = new Date(value);\n            yearStart.setMonth(0);\n            yearStart.setDate(1);\n            yearStart.setHours(0);\n            yearStart.setMinutes(0);\n            yearStart.setSeconds(0);\n            yearStart.setMilliseconds(0);\n            // Whether a tick value is the start of a year\n            if (date.getTime() === yearStart.getTime()) {\n                return &#39;{year|&#39; + date.getFullYear() + &#39;}\\n&#39;\n                    + &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;;\n            }\n            else {\n                return &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;\n            }\n        },\n        rich: {\n            year: {\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            month: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n","default":null},"showMinLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the min tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the min tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"showMaxLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the max tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the max tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"color":{"type":["Color","Function"],"description":"\n\n<p>Color of axis label is set to be <a href=\"#xAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default. Callback function is supported, in the following format:</p>\n<pre><code class=\"lang-js\">(val: string) =&gt; Color\n</code></pre>\n<p>Parameter is the text of label, and return value is the color. See the following example:</p>\n<pre><code class=\"lang-js\">textStyle: {\n    color: function (value, index) {\n        return value &gt;= 0 ? &#39;green&#39; : &#39;red&#39;;\n    }\n}\n</code></pre>\n","uiControl":{"type":"color"}},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"splitLine":{"type":["Object"],"description":"<p>Split line of axis in <a href=\"#grid\">grid</a> area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the splitLine from showing.\n<code class=\"codespan\">value</code> type axes are shown by default, while <code class=\"codespan\">category</code> type axes are hidden.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis splitLine, which is available in category axis.  is set to be the same as <a href=\"#xAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Array","string"],"description":"\n\n<p>The color of the splitLine, which could be set separately.</p>\n<p>SplitLine color could also be set in color array, which the split lines would take as their colors in turns.</p>\n<p>Example:</p>\n<pre><code>splitLine: {\n    lineStyle: {\n        // Dark and light colors will be used in turns\n        color: [&#39;#aaa&#39;, &#39;#ddd&#39;]\n    }\n}\n</code></pre>","uiControl":{"type":"color"},"default":"['#ccc']"},"width":{"type":["number"],"description":"\n\n<p>splitLine line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>splitLine line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"minorSplitLine":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.6.0</code></p>\n</blockquote>\n<p>Minor split lines of axis in the <a href=\"#grid\">grid</a> area。It will align to the <a href=\"#xAxis.minorTick\">minorTick</a></p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>If show minor split lines.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>minorSplitLineLine color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#eee'"},"width":{"type":["number"],"description":"\n\n<p>minorSplitLine line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>minorSplitLine line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"splitArea":{"type":["Object"],"description":"<p>Split area of axis in <a href=\"#grid\">grid</a> area, not shown by default.</p>\n","properties":{"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis splitArea, which is available in category axis.  is set to be the same as <a href=\"#xAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> to show the splitArea.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"areaStyle":{"type":["Object"],"description":"<p>Split area style.</p>\n","properties":{"color":{"type":["Array"],"description":"<p>Color of split area.\nSplitArea color could also be set in color array, which the split lines would take as their colors in turns. Dark and light colors in turns are used by default.</p>\n","default":"['rgba(250,250,250,0.3)','rgba(200,200,200,0.3)']"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Category data, available in <a href=\"#xAxis.type\">type</a>: &#39;category&#39; axis.</p>\n<p>If <a href=\"#xAxis.type\">type</a> is not specified, but <code class=\"codespan\">axis.data</code> is specified, the <a href=\"#xAxis.type\">type</a> is auto set as <code class=\"codespan\">&#39;category&#39;</code>.</p>\n<p>If <a href=\"#xAxis.type\">type</a> is specified as <code class=\"codespan\">&#39;category&#39;</code>, but <code class=\"codespan\">axis.data</code> is not specified, <code class=\"codespan\">axis.data</code> will be auto collected from <a href=\"#series.data\">series.data</a>. It brings convenience, but we should notice that <code class=\"codespan\">axis.data</code> provides then value range of the <code class=\"codespan\">&#39;category&#39;</code> axis. If  it is auto collected from <a href=\"#series.data\">series.data</a>, Only the values appearing in <a href=\"#series.data\">series.data</a> can be collected. For example, if <a href=\"#series.data\">series.data</a> is empty, nothing will be collected.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Name list of all categories\ndata: [&#39;Monday&#39;, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;, &#39;Friday&#39;, &#39;Saturday&#39;, &#39;Sunday&#39;]\n// Each item could also be a specific configuration item.\n// In this case, `value` is used as the category name.\ndata: [{\n    value: &#39;Monday&#39;,\n    // Highlight Monday\n    textStyle: {\n        fontSize: 20,\n        color: &#39;red&#39;\n    }\n}, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;, &#39;Friday&#39;, &#39;Saturday&#39;, &#39;Sunday&#39;]\n</code></pre>\n","items":{"type":"Object","properties":{"value":{"type":["string"],"description":"<p>Name of a category.</p>\n"},"textStyle":{"type":["Object"],"description":"<p>Text style of the category.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}},"axisPointer":{"type":["Object"],"description":"<p>axisPointer settings on the axis.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>axisPointer will not be displayed by default. But if <a href=\"#tooltip.trigger\">tooltip.trigger</a> is set as <code class=\"codespan\">&#39;axis&#39;</code> or <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, axisPointer will be displayed automatically. Each coordinate system will automatically chose the axes whose will display its axisPointer. <a href=\"#tooltip.axisPointer.axis\">tooltip.axisPointer.axis</a> can be used to change the choice.</p>\n","uiControl":{"type":"boolean"},"default":false},"type":{"type":["string"],"description":"\n\n<p>Indicator type.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;line&#39;</code> line indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;shadow&#39;</code> shadow crosshair indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code> no indicator displayed.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"line,shadow,none"},"default":"'line'"},"snap":{"type":["boolean"],"description":"<p>Whether snap to point automatically. The default value is auto determined.</p>\n<p>This feature usually makes sense in value axis and time axis, where tiny points can be seeked automatically.</p>\n"},"z":{"type":["number"],"description":"<p>z value, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n"},"label":{"type":["Object"],"description":"<p>label of axisPointer</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label. Label will not show by default. But if <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, label will be displayed automatically.</p>\n","default":false},"precision":{"type":["number","string"],"description":"<p>The precision of value in label. It is auto determined by default. You can also set it as <code class=\"codespan\">&#39;2&#39;</code>, which indicates that two decimal fractions are reserved.</p>\n","default":"'auto'"},"formatter":{"type":["string","Function"],"description":"<p>The formatter of label.</p>\n<p>If set as <code class=\"codespan\">string</code>, for example it can be: <code class=\"codespan\">formatter: &#39;some text {value} some text</code>, where <code class=\"codespan\">{value}</code> will be replaced by axis value automatically.</p>\n<p>If set as <code class=\"codespan\">function</code>:</p>\n<p><strong>Parameters:</strong></p>\n<p><code class=\"codespan\">{Object}</code> params: Including fields as follows:</p>\n<p><code class=\"codespan\">{Object}</code> params.value: current value of this axis. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;category&#39;</code>, it is one of the value in <code class=\"codespan\">axis.data</code>. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;time&#39;</code>, it is a timestamp.</p>\n<p><code class=\"codespan\">{Array.&lt;Object&gt;}</code> params.seriesData: An array, containing info of nearest points. Each item is:</p>\n<p><code class=\"codespan\">{string}</code> params.axisDimension: The dimension name of the axis. For example, in catesian it will be <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, and in polar it will be <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code>.</p>\n<p><code class=\"codespan\">{number}</code> params.axisIndex: The index of the axis, for example, <code class=\"codespan\">0</code>,<code class=\"codespan\">1</code>, <code class=\"codespan\">2</code>, ...</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>Each item also includes axis infomation:</p>\n<pre><code class=\"lang-js\">{\n    axisDim: &#39;x&#39;, // &#39;x&#39;, &#39;y&#39;, &#39;angle&#39;, &#39;radius&#39;, &#39;single&#39;\n    axisId: &#39;xxx&#39;,\n    axisName: &#39;xxx&#39;,\n    axisIndex: 3,\n    axisValue: 121, // The current value of axisPointer\n    axisValueLabel: &#39;text of value&#39;\n}\n</code></pre>\n<p><strong>Return:</strong></p>\n<p>The string to be displayed.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">formatter: function (params) {\n    // If axis.type is &#39;time&#39;\n    return &#39;some text&#39; + echarts.format.formatTime(params.value);\n}\n</code></pre>\n","default":null},"margin":{"type":["boolean"],"description":"<p>Distance between label and axis.</p>\n","default":3},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"padding":{"type":["string","Array"],"description":"\n\n<p>axisPointer space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":"[5, 7, 5, 7]"},"backgroundColor":{"type":["string"],"description":"<p>Background color of label, the same as <a href=\"#xAxis.axisLine.lineStyle.color\">axis.axisLine.lineStyle.color</a> by default.</p>\n","default":"'auto'"},"borderColor":{"type":["string"],"description":"<p>Border color of label.</p>\n","default":null},"borderWidth":{"type":["string"],"description":"<p>Border width of label.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"lineStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;line&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#555"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"shadowStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;shadow&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'rgba(150,150,150,0.3)"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"triggerTooltip":{"type":["boolean"],"description":"\n\n<p>Whether to trigger tooltip.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"value":{"type":["number"],"description":"<p>current value. When using <a href=\"xAxisPointer.handle\" target=\"_blank\">axisPointer.handle</a>, <code class=\"codespan\">value</code> can be set to define the initail position of axisPointer.</p>\n","default":null},"status":{"type":["boolean"],"description":"\n\n<p>Current status, can be <code class=\"codespan\">&#39;show&#39;</code> 和 <code class=\"codespan\">&#39;hide&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"show,hide"}},"handle":{"type":["Object"],"description":"<p>A button used to drag axisPointer. This feature is applicable in touch device. See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-tooltip-touch&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set to <code class=\"codespan\">true</code> to use handle.</p>\n","uiControl":{"type":"boolean"},"default":false},"icon":{"type":["*"],"description":"\n\n<p>The icon of the handle.</p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/axisPointer-handle-image&amp;edit=1&amp;reset=1\" target=\"_blank\">example of using image</a></p>\n","uiControl":{"type":"icon","clean":"true"}},"size":{"type":["number","Array"],"description":"\n\n<p>The size of the handle, which can be set as a single value or an array (<code class=\"codespan\">[width, height]</code>).</p>\n","uiControl":{"type":"vector","default":"45,45","min":"0","step":"0.5","dims":"width,height"},"default":45},"margin":{"type":["number"],"description":"\n\n<p>Distance from handle center to axis.</p>\n","uiControl":{"type":"number","default":"50","min":"0","step":"0.5"},"default":50},"color":{"type":["string"],"description":"\n\n<p>The color of the handle.</p>\n","uiControl":{"type":"color"},"default":"'#333'"},"throttle":{"type":["number"],"description":"\n\n<p>Throttle rate of trigger view update when dragging handle, in ms. Increase the value to improve performance, but decrease the experience.</p>\n","uiControl":{"type":"number","default":"40","min":"0","step":"10"},"default":40},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"2","step":"0.5"},"default":2},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in x axis.</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in x axis, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":0}}},"yAxis":{"type":["Object"],"description":"<p>The y axis in cartesian(rectangular) coordinate. Usually a single grid component can place at most 2 y axis, one on the left and another on the right. <a href=\"#yAxis.offset\">offset</a> can be used to avoid overlap when you need to put more than two y axis.</p>\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"gridIndex":{"type":["number"],"description":"<p>The index of grid which the y axis belongs to. Defaults to be in the first grid.</p>\n","default":0},"position":{"type":["string"],"description":"\n\n<p>the position of y axis.</p>\n<p>options:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>The first y axis in grid defaults to be the left (<code class=\"codespan\">&#39;left&#39;</code>)  of the grid, and the second y axis is on the other side against the first y axis.</p>\n","uiControl":{"type":"enum","options":"left,right","default":"left"}},"offset":{"type":["number"],"description":"\n\n<p>Offset of y axis relative to default position. Useful when multiple y axis has same <a href=\"#yAxis.position\">position</a> value.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"realtimeSort":{"type":["*"],"description":"<p><code class=\"codespan\">realtimeSort</code> is used to enable bar race if set to be <code class=\"codespan\">true</code>. It is only valid if the <a href=\"#yAxis.type\">type</a> of yAxis is <code class=\"codespan\">&#39;value&#39;</code>.</p>\n<p>It should be used along with other options to enable bar race. Please refer to <a href=\"tutorial.html#Bar%20Race\" target=\"_blank\">bar race</a> tutorial for more details.</p>\n","default":false},"sortSeriesIndex":{"type":["*"],"description":"<p>The index of series used to sort in bar race. Since only one series is supported in bar race, <code class=\"codespan\">sortSeriesIndex</code> should always be <code class=\"codespan\">0</code>. It is only valid if <a href=\"#yAxis.realtimeSort\">realtimeSort</a> is <code class=\"codespan\">true</code> and <a href=\"#yAxis.type\">type</a> is <code class=\"codespan\">&#39;value&#39;</code>.</p>\n<p>It should be used along with other options to enable bar race. Please refer to <a href=\"tutorial.html#Bar%20Race\" target=\"_blank\">bar race</a> tutorial for more details.</p>\n","default":0},"type":{"type":["string"],"description":"<p>Type of axis.</p>\n<p>Option:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;value&#39;</code>\n  Numerical axis, suitable for continuous data.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;category&#39;</code>\n  Category axis, suitable for discrete category data. Category data can be auto retrieved from <a href=\"#series.data\">series.data</a> or <a href=\"#dataset.source\">dataset.source</a>, or can be specified via <a href=\"#yAxis.data\">yAxis.data</a>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;time&#39;</code>\n  Time axis, suitable for continuous time series data. As compared to value axis, it has a better formatting for time and a different tick calculation method. For example, it decides to use month, week, day or hour for tick based on the range of span.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;log&#39;</code>\n  Log axis, suitable for log data.</p>\n</li>\n</ul>\n","default":"'value'"},"name":{"type":["string"],"description":"\n\n<p>Name of axis.</p>\n","uiControl":{"type":"text"}},"nameLocation":{"type":["string"],"description":"\n\n<p>Location of axis name.</p>\n<p><strong>Options: </strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> or <code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","options":"start,middle,end","default":"end"},"default":"'end'"},"nameTextStyle":{"type":["Object"],"description":"<p>Text style of axis name.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Color of axis name uses <a href=\"#yAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default.</p>\n","uiControl":{"type":"color"}},"fontStyle":{"type":["string"],"description":"\n\n<p>axis name font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p>axis name font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p>axis name font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p>axis name font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"nameGap":{"type":["number"],"description":"\n\n<p>Gap between axis name and axis line.</p>\n","uiControl":{"type":"number","step":"0.5","default":"15"},"default":15},"nameRotate":{"type":["number"],"description":"\n\n<p>Rotation of axis name.</p>\n","uiControl":{"type":"angle","min":"-360","max":"360","step":"1"},"default":null},"inverse":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> to invert the axis.\nThis is a new option available from Echarts 3 and newer.</p>\n","uiControl":{"type":"boolean"},"default":false},"boundaryGap":{"type":["boolean","Array"],"description":"\n\n<p>The boundary gap on both sides of a coordinate axis. The setting and behavior of category axes and non-category axes are different.</p>\n<p>The <code class=\"codespan\">boundaryGap</code> of category axis can be set to either <code class=\"codespan\">true</code> or <code class=\"codespan\">false</code>. Default value is set to be <code class=\"codespan\">true</code>, in which case <a href=\"#yAxis.axisTick\">axisTick</a> is served only as a separation line, and labels and data appear only in the center part of two <a href=\"#yAxis.axisTick\">axis ticks</a>, which is called <em>band</em>.</p>\n<p>For non-category axis, including time, numerical value, and log axes, <code class=\"codespan\">boundaryGap</code> is an array of two values, representing the spanning range between minimum and maximum value. The value can be set in numeric value or relative percentage, which becomes invalid after setting <a href=\"#yAxis.min\">min</a> and <a href=\"#yAxis.max\">max</a>.\n<strong>Example: </strong></p>\n<pre><code class=\"lang-js\">boundaryGap: [&#39;20%&#39;, &#39;20%&#39;]\n</code></pre>\n","uiControl":{"type":"boolean"}},"min":{"type":["number","string","Function"],"description":"\n\n<p>The minimun value of axis.</p>\n<p>It can be set to a special value <code class=\"codespan\">&#39;dataMin&#39;</code> so that the minimum value on this axis is set to be the minimum label.</p>\n<p>It will be automatically computed to make sure axis tick is equally distributed when not set.</p>\n<p>In category axis, it can also be set as the ordinal number. For example, if a catergory axis has <code class=\"codespan\">data: [&#39;categoryA&#39;, &#39;categoryB&#39;, &#39;categoryC&#39;]</code>, and the ordinal <code class=\"codespan\">2</code> represents <code class=\"codespan\">&#39;categoryC&#39;</code>. Moreover, it can be set as negative number, like <code class=\"codespan\">-3</code>.</p>\n<p>If <code class=\"codespan\">min</code> is specified as a function, it should return a min value, like:</p>\n<pre><code class=\"lang-js\">min: function (value) {\n    return value.min - 20;\n}\n</code></pre>\n<p><code class=\"codespan\">value</code> is an object, containing the <code class=\"codespan\">min</code> value and <code class=\"codespan\">max</code> value of the data. This function should return the min value of axis, or return <code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> to make echarts use the auto calculated min value (<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> return is only supported since <code class=\"codespan\">v4.8.0</code>).</p>\n","uiControl":{"type":"number"},"default":null},"max":{"type":["number","string","Function"],"description":"\n\n<p>The maximum value of axis.</p>\n<p>It can be set to a special value <code class=\"codespan\">&#39;dataMax&#39;</code> so that the minimum value on this axis is set to be the maximum label.</p>\n<p>It will be automatically computed to make sure axis tick is equally distributed when not set.</p>\n<p>In category axis, it can also be set as the ordinal number. For example, if a catergory axis has <code class=\"codespan\">data: [&#39;categoryA&#39;, &#39;categoryB&#39;, &#39;categoryC&#39;]</code>, and the ordinal <code class=\"codespan\">2</code> represents <code class=\"codespan\">&#39;categoryC&#39;</code>. Moreover, it can be set as negative number, like <code class=\"codespan\">-3</code>.</p>\n<p>If <code class=\"codespan\">max</code> is specified as a function, it should return a max value, like:</p>\n<pre><code class=\"lang-js\">max: function (value) {\n    return value.max - 20;\n}\n</code></pre>\n<p><code class=\"codespan\">value</code> is an object, containing the <code class=\"codespan\">min</code> value and <code class=\"codespan\">max</code> value of the data. This function should return the max value of axis, or return <code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> to make echarts use the auto calculated max value (<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> return is only supported since <code class=\"codespan\">v4.8.0</code>).</p>\n","uiControl":{"type":"number"},"default":null},"scale":{"type":["boolean"],"description":"\n\n<p>It is available only in numerical axis, i.e., <a href=\"#yAxis.type\">type</a>: &#39;value&#39;.</p>\n<p>It specifies whether not to contain zero position of axis compulsively. When it is set to be <code class=\"codespan\">true</code>, the axis may not contain zero position, which is useful in the scatter chart for both value axes.</p>\n<p>This configuration item is unavailable when the <a href=\"#yAxis.min\">min</a> and <a href=\"#yAxis.max\">max</a> are set.</p>\n","uiControl":{"type":"boolean"},"default":false},"splitNumber":{"type":["number"],"description":"\n\n<p>Number of segments that the axis is split into. Note that this number serves only as a recommendation, and the true segments may be adjusted based on readability.</p>\n<p>This is unavailable for category axis.</p>\n","uiControl":{"type":"number","min":"1","step":"1","default":"5"},"default":5},"minInterval":{"type":["number"],"description":"\n\n<p>Minimum gap between split lines.</p>\n<p>For example, it can be set to be <code class=\"codespan\">1</code> to make sure axis label is show as integer.</p>\n<pre><code class=\"lang-js\">{\n    minInterval: 1\n}\n</code></pre>\n<p>It is available only for axis of <a href=\"#yAxis.type\">type</a> &#39;value&#39; or &#39;time&#39;.</p>\n","uiControl":{"type":"number"},"default":0},"maxInterval":{"type":["number"],"description":"\n\n<p>Maximum gap between split lines.</p>\n<p>For example, in time axis (<a href=\"#yAxis.type\">type</a> is &#39;time&#39;), it can be set to be <code class=\"codespan\">3600 * 24 * 1000</code> to make sure that the gap between axis labels is less than or equal to one day.</p>\n<pre><code class=\"lang-js\">{\n    maxInterval: 3600 * 1000 * 24\n}\n</code></pre>\n<p>It is available only for axis of <a href=\"#yAxis.type\">type</a> &#39;value&#39; or &#39;time&#39;.</p>\n","uiControl":{"type":"number"}},"interval":{"type":["number"],"description":"\n\n<p>Compulsively set segmentation interval for axis.</p>\n<p>As <a href=\"#yAxis.splitNumber\">splitNumber</a> is a recommendation value, the calculated tick may not be the same as expected. In this case, interval should be used along with <a href=\"#yAxis.min\">min</a> and <a href=\"#yAxis.max\">max</a> to compulsively set tickings. But in most cases, we do not suggest using this, out automatic calculation is enough for most situations.</p>\n<p>This is unavailable for category axis. Timestamp should be passed for <a href=\"#yAxis.type\">type</a>: &#39;time&#39; axis. Logged value should be passed for <a href=\"#yAxis.type\">type</a>: &#39;log&#39; axis.</p>\n","uiControl":{"type":"number"}},"logBase":{"type":["number"],"description":"\n\n<p>Base of logarithm, which is valid only for numeric axes with <a href=\"#yAxis.type\">type</a>: &#39;log&#39;.</p>\n","uiControl":{"type":"number","default":"10"},"default":10},"silent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code>, to prevent interaction with the axis.</p>\n","default":false},"triggerEvent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code> to enable triggering events.</p>\n<p>Parameters of the event include:</p>\n<pre><code class=\"lang-js\">{\n    // Component type: xAxis, yAxis, radiusAxis, angleAxis\n    // Each of which has an attribute for index, e.g., xAxisIndex for xAxis\n    componentType: string,\n    // Value on axis before being formatted.\n    // Click on value label to trigger event.\n    value: &#39;&#39;,\n    // Name of axis.\n    // Click on laben name to trigger event.\n    name: &#39;&#39;\n}\n</code></pre>\n","default":false},"axisLine":{"type":["Object"],"description":"<p>Settings related to axis line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis line from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"onZero":{"type":["boolean"],"description":"\n\n<p>Specifies whether X or Y axis lies on the other&#39;s origin position, where value is 0 on axis. Valid only if the other axis is of value type, and contains 0 value.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"onZeroAxisIndex":{"type":["number"],"description":"<p>When mutiple axes exists, this option can be used to specify which axis can be &quot;onZero&quot; to.</p>\n"},"symbol":{"type":["string","Array"],"description":"\n\n<p>Symbol of the two ends of the axis. It could be a string, representing the same symbol for two ends; or an array with two string elements, representing the two ends separately. It&#39;s set to be <code class=\"codespan\">&#39;none&#39;</code> by default, meaning no arrow for either end. If it is set to be <code class=\"codespan\">&#39;arrow&#39;</code>, there shall be two arrows. If there should only one arrow at the end, it should set to be <code class=\"codespan\">[&#39;none&#39;, &#39;arrow&#39;]</code>.</p>\n","uiControl":{"type":"icon","default":"none"},"default":"'none'"},"symbolSize":{"type":["Array"],"description":"\n\n<p>Size of the arrows at two ends. The first is the width perpendicular to the axis, the next is the width parallel to the axis.</p>\n","uiControl":{"type":"vector","default":"10,15"},"default":"[10, 15]"},"symbolOffset":{"type":["Array","number"],"description":"\n\n<p>Arrow offset of axis. If is array, the first number is the offset of the arrow at the beginning, and the second number is the offset of the arrow at the end. If is number, it means the arrows have the same offset.</p>\n","uiControl":{"type":"vector","default":"0,0"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>line styleLine color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#333'"},"width":{"type":["number"],"description":"\n\n<p>line style line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>line style line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisTick":{"type":["Object"],"description":"<p>Settings related to axis tick.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis tick from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"alignWithLabel":{"type":["boolean"],"description":"\n\n<p>Align axis tick with label, which is available only when <code class=\"codespan\">boundaryGap</code> is set to be <code class=\"codespan\">true</code> in category axis. See the following picture:</p>\n<p><img width=\"600\" height=\"auto\" src=\"documents/asset/img/axis-align-with-label.png\"></p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of axisTick, which is available in category axis.  is set to be the same as <a href=\"#yAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"inside":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> so the axis labels face the <code class=\"codespan\">inside</code> direction.</p>\n","uiControl":{"type":"boolean"},"default":false},"length":{"type":["number"],"description":"\n\n<p>The length of the axis tick.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"5"},"default":5},"lineStyle":{"type":["Object"],"description":"<p>Line style of axis ticks.</p>\n","properties":{"color":{"type":["Color"],"description":"<p>Color of axis label is set to be <a href=\"#yAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default.</p>\n"},"width":{"type":["number"],"description":"\n\n<p>axisTick line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>axisTick line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"minorTick":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.6.0</code></p>\n</blockquote>\n<p>Settings related minor ticks.</p>\n<p>Note: <code class=\"codespan\">minorTick</code> is not available in the <code class=\"codespan\">category</code> type axis.</p>\n<p>Examples:</p>\n<p>1) Using minor ticks in function plotting.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-function&edit=1&reset=1\" width=\"600\" height=\"350\"></iframe>\n\n\n<p>2) Using minor ticks in log axis.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-log&edit=1&reset=1\" width=\"600\" height=\"350\"></iframe>\n\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>If show minor ticks.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"splitNumber":{"type":["number"],"description":"\n\n<p>Number of interval splited by minor ticks.</p>\n","uiControl":{"type":"number","min":"1","step":"1","default":"5"},"default":5},"length":{"type":["number"],"description":"\n\n<p>Length of minor ticks lines。</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"3"},"default":3},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Style configuration of minor ticks lines <a href=\"#yAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a>。</p>\n","uiControl":{"type":"color"}},"width":{"type":["number"],"description":"\n\n<p>minorTick line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>minorTick line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisLabel":{"type":["Object"],"description":"<p>Settings related to axis label.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis label from appearing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis label, which is available in category axis. </p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"inside":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> so the axis labels face the <code class=\"codespan\">inside</code> direction.</p>\n","uiControl":{"type":"boolean"},"default":false},"rotate":{"type":["number"],"description":"\n\n<p>Rotation degree of axis label, which is especially useful when there is no enough space for category axis.</p>\n<p>Rotation degree is from -90 to 90.</p>\n","uiControl":{"type":"angle","min":"-90","max":"90","step":"1"},"default":0},"margin":{"type":["number"],"description":"\n\n<p>The margin between the axis label and the axis line.</p>\n","uiControl":{"type":"number","default":"8","step":"0.5"},"default":8},"formatter":{"type":["string","Function"],"description":"<p>Formatter of axis label, which supports string template and callback function.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use string template; template variable is the default label of axis {value}\nformatter: &#39;{value} kg&#39;\n// Use callback.\nformatter: function (value, index) {\n    return value + &#39;kg&#39;;\n}\n</code></pre>\n<hr>\n<p>For axes of time <a href=\"#.type\">type</a>: <code class=\"codespan\">&#39;time&#39;</code>, <code class=\"codespan\">formatter</code> supports the following forms:</p>\n<ul>\n<li><strong>String Templates</strong>: an easy and fast way to make frequently used date/time template, formed in <code class=\"codespan\">string</code></li>\n<li><strong>Callback Functions</strong>: customized formatter to make complex format, formed in <code class=\"codespan\">Function</code></li>\n<li><strong>Cascading Templates</strong>: to adopt different formatters for different time granularity, formed in <code class=\"codespan\">object</code></li>\n</ul>\n<p>Next, we are going to introduce these three forms one by one.</p>\n<p><strong> String Templates </strong></p>\n<p>Using string templates is an easy way to format date/time with frequently used formats. If it can be used to make what you want, you are advised to do so. If not, you could then consider the others. Supported formats are:</p>\n<table>\n<thead>\n<tr>\n<th>Group</th>\n<th>Template</th>\n<th>Value (EN)</th>\n<th>Value (ZH)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Year</td>\n<td>{yyyy}</td>\n<td>e.g., 2020, 2021, ...</td>\n<td>例：2020, 2021, ...</td>\n</tr>\n<tr>\n<td></td>\n<td>{yy}</td>\n<td>00-99</td>\n<td>00-99</td>\n</tr>\n<tr>\n<td>Quarter</td>\n<td>{Q}</td>\n<td>1, 2, 3, 4</td>\n<td>1, 2, 3, 4</td>\n</tr>\n<tr>\n<td>Month</td>\n<td>{MMMM}</td>\n<td>e.g., January, February, ...</td>\n<td>一月、二月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MMM}</td>\n<td>e.g., Jan, Feb, ...</td>\n<td>1月、2月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MM}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{M}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Day of Month</td>\n<td>{dd}</td>\n<td>01-31</td>\n<td>01-31</td>\n</tr>\n<tr>\n<td></td>\n<td>{d}</td>\n<td>1-31</td>\n<td>1-31</td>\n</tr>\n<tr>\n<td>Day of Week</td>\n<td>{eeee}</td>\n<td>Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday</td>\n<td>星期日、星期一、星期二、星期三、星期四、星期五、星期六</td>\n</tr>\n<tr>\n<td></td>\n<td>{ee}</td>\n<td>Sun, Mon, Tues, Wed, Thu, Fri, Sat</td>\n<td>日、一、二、三、四、五、六</td>\n</tr>\n<tr>\n<td></td>\n<td>{e}</td>\n<td>1-54</td>\n<td>1-54</td>\n</tr>\n<tr>\n<td>Hour</td>\n<td>{HH}</td>\n<td>00-23</td>\n<td>00-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{H}</td>\n<td>0-23</td>\n<td>0-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{hh}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{h}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Minute</td>\n<td>{mm}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{m}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Second</td>\n<td>{ss}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{s}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Millisecond</td>\n<td>{SSS}</td>\n<td>000-999</td>\n<td>000-999</td>\n</tr>\n<tr>\n<td></td>\n<td>{S}</td>\n<td>0-999</td>\n<td>0-999</td>\n</tr>\n</tbody>\n</table>\n<blockquote>\n<p>Templates of other languages can be found in <a href=\"https://github.com/apache/echarts/tree/master/src/i18n\" target=\"_blank\">the language package</a>. Please refer to <a href=\"api.html#echarts.registerLocale\" target=\"_blank\">echarts.registerLocale</a> to register a language.</p>\n</blockquote>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: &#39;{yyyy}-{MM}-{dd}&#39; // gets labels like &#39;2020-12-02&#39;\nformatter: &#39;Day {d}&#39; // gets labels like &#39;Day 2&#39;\n</code></pre>\n<p><strong> Callback Functions </strong></p>\n<p>Callback functions can be used to get different formats for different axis tick values. Sometimes, if you have complex date/time formatting requirement, third-party libraries like <a href=\"https://momentjs.com/\" target=\"_blank\">Moment.js</a> or <a href=\"https://date-fns.org/\" target=\"_blank\">date-fns</a> can be used to return formatted labels.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use callback function; function parameters are axis index\nformatter: function (value, index) {\n    // Formatted to be month/day; display year only in the first label\n    var date = new Date(value);\n    var texts = [(date.getMonth() + 1), date.getDate()];\n    if (idx === 0) {\n        texts.unshift(date.getYear());\n    }\n    return texts.join(&#39;/&#39;);\n}\n</code></pre>\n<p><strong> Cascading Templates </strong></p>\n<p>Sometimes, we wish to use different formats for different time granularity. For example, in a quarter-year chart, we may wish to see the month name with the first date of the month, while see the date name with others. This can be made with:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: {\n    month: &#39;{MMMM}&#39;, // Jan, Feb, ...\n    day: &#39;{d}&#39; // 1, 2, ...\n}\n</code></pre>\n<p>Supported levels and their default formatters are:</p>\n<pre><code class=\"lang-js\">{\n    year: &#39;{yyyy}&#39;,\n    month: &#39;{MMM}&#39;,\n    day: &#39;{d}&#39;,\n    hour: &#39;{HH}:{mm}&#39;,\n    minute: &#39;{HH}:{mm}&#39;,\n    second: &#39;{HH}:{mm}:{ss}&#39;,\n    millisecond: &#39;{hh}:{mm}:{ss} {SSS}&#39;,\n    none: &#39;{yyyy}-{MM}-{dd} {hh}:{mm}:{ss} {SSS}&#39;\n}\n</code></pre>\n<p>Let&#39;s take <code class=\"codespan\">day</code> for example. When a tick value is <code class=\"codespan\">0</code> for its hour, minute, second, and millisecond, <code class=\"codespan\">day</code> level will be used to make formatter. <code class=\"codespan\">none</code> is used when no other level fulfills, which is for tick values with millisecond values other than <code class=\"codespan\">0</code>.</p>\n<p><strong> Rich Text </strong></p>\n<p>The above three forms all support rich text, so it can be used to make some complex effects.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: {\n            // Display year and month information on the first data of a year\n            year: &#39;{yearStyle|{yyyy}}\\n{monthStyle|{MMM}}&#39;,\n            month: &#39;{monthStyle|{MMM}}&#39;\n        },\n        rich: {\n            yearStyle: {\n                // Make yearly text more standing out\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            monthStyle: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n<p>The above example can also be made with a callback function:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: function (value) {\n            const date = new Date(value);\n            const yearStart = new Date(value);\n            yearStart.setMonth(0);\n            yearStart.setDate(1);\n            yearStart.setHours(0);\n            yearStart.setMinutes(0);\n            yearStart.setSeconds(0);\n            yearStart.setMilliseconds(0);\n            // Whether a tick value is the start of a year\n            if (date.getTime() === yearStart.getTime()) {\n                return &#39;{year|&#39; + date.getFullYear() + &#39;}\\n&#39;\n                    + &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;;\n            }\n            else {\n                return &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;\n            }\n        },\n        rich: {\n            year: {\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            month: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n","default":null},"showMinLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the min tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the min tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"showMaxLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the max tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the max tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"color":{"type":["Color","Function"],"description":"\n\n<p>Color of axis label is set to be <a href=\"#yAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default. Callback function is supported, in the following format:</p>\n<pre><code class=\"lang-js\">(val: string) =&gt; Color\n</code></pre>\n<p>Parameter is the text of label, and return value is the color. See the following example:</p>\n<pre><code class=\"lang-js\">textStyle: {\n    color: function (value, index) {\n        return value &gt;= 0 ? &#39;green&#39; : &#39;red&#39;;\n    }\n}\n</code></pre>\n","uiControl":{"type":"color"}},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"splitLine":{"type":["Object"],"description":"<p>Split line of axis in <a href=\"#grid\">grid</a> area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the splitLine from showing.\n<code class=\"codespan\">value</code> type axes are shown by default, while <code class=\"codespan\">category</code> type axes are hidden.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis splitLine, which is available in category axis.  is set to be the same as <a href=\"#yAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Array","string"],"description":"\n\n<p>The color of the splitLine, which could be set separately.</p>\n<p>SplitLine color could also be set in color array, which the split lines would take as their colors in turns.</p>\n<p>Example:</p>\n<pre><code>splitLine: {\n    lineStyle: {\n        // Dark and light colors will be used in turns\n        color: [&#39;#aaa&#39;, &#39;#ddd&#39;]\n    }\n}\n</code></pre>","uiControl":{"type":"color"},"default":"['#ccc']"},"width":{"type":["number"],"description":"\n\n<p>splitLine line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>splitLine line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"minorSplitLine":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.6.0</code></p>\n</blockquote>\n<p>Minor split lines of axis in the <a href=\"#grid\">grid</a> area。It will align to the <a href=\"#yAxis.minorTick\">minorTick</a></p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>If show minor split lines.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>minorSplitLineLine color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#eee'"},"width":{"type":["number"],"description":"\n\n<p>minorSplitLine line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>minorSplitLine line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"splitArea":{"type":["Object"],"description":"<p>Split area of axis in <a href=\"#grid\">grid</a> area, not shown by default.</p>\n","properties":{"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis splitArea, which is available in category axis.  is set to be the same as <a href=\"#yAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> to show the splitArea.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"areaStyle":{"type":["Object"],"description":"<p>Split area style.</p>\n","properties":{"color":{"type":["Array"],"description":"<p>Color of split area.\nSplitArea color could also be set in color array, which the split lines would take as their colors in turns. Dark and light colors in turns are used by default.</p>\n","default":"['rgba(250,250,250,0.3)','rgba(200,200,200,0.3)']"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Category data, available in <a href=\"#yAxis.type\">type</a>: &#39;category&#39; axis.</p>\n<p>If <a href=\"#yAxis.type\">type</a> is not specified, but <code class=\"codespan\">axis.data</code> is specified, the <a href=\"#yAxis.type\">type</a> is auto set as <code class=\"codespan\">&#39;category&#39;</code>.</p>\n<p>If <a href=\"#yAxis.type\">type</a> is specified as <code class=\"codespan\">&#39;category&#39;</code>, but <code class=\"codespan\">axis.data</code> is not specified, <code class=\"codespan\">axis.data</code> will be auto collected from <a href=\"#series.data\">series.data</a>. It brings convenience, but we should notice that <code class=\"codespan\">axis.data</code> provides then value range of the <code class=\"codespan\">&#39;category&#39;</code> axis. If  it is auto collected from <a href=\"#series.data\">series.data</a>, Only the values appearing in <a href=\"#series.data\">series.data</a> can be collected. For example, if <a href=\"#series.data\">series.data</a> is empty, nothing will be collected.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Name list of all categories\ndata: [&#39;Monday&#39;, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;, &#39;Friday&#39;, &#39;Saturday&#39;, &#39;Sunday&#39;]\n// Each item could also be a specific configuration item.\n// In this case, `value` is used as the category name.\ndata: [{\n    value: &#39;Monday&#39;,\n    // Highlight Monday\n    textStyle: {\n        fontSize: 20,\n        color: &#39;red&#39;\n    }\n}, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;, &#39;Friday&#39;, &#39;Saturday&#39;, &#39;Sunday&#39;]\n</code></pre>\n","items":{"type":"Object","properties":{"value":{"type":["string"],"description":"<p>Name of a category.</p>\n"},"textStyle":{"type":["Object"],"description":"<p>Text style of the category.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}},"axisPointer":{"type":["Object"],"description":"<p>axisPointer settings on the axis.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>axisPointer will not be displayed by default. But if <a href=\"#tooltip.trigger\">tooltip.trigger</a> is set as <code class=\"codespan\">&#39;axis&#39;</code> or <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, axisPointer will be displayed automatically. Each coordinate system will automatically chose the axes whose will display its axisPointer. <a href=\"#tooltip.axisPointer.axis\">tooltip.axisPointer.axis</a> can be used to change the choice.</p>\n","uiControl":{"type":"boolean"},"default":false},"type":{"type":["string"],"description":"\n\n<p>Indicator type.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;line&#39;</code> line indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;shadow&#39;</code> shadow crosshair indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code> no indicator displayed.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"line,shadow,none"},"default":"'line'"},"snap":{"type":["boolean"],"description":"<p>Whether snap to point automatically. The default value is auto determined.</p>\n<p>This feature usually makes sense in value axis and time axis, where tiny points can be seeked automatically.</p>\n"},"z":{"type":["number"],"description":"<p>z value, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n"},"label":{"type":["Object"],"description":"<p>label of axisPointer</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label. Label will not show by default. But if <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, label will be displayed automatically.</p>\n","default":false},"precision":{"type":["number","string"],"description":"<p>The precision of value in label. It is auto determined by default. You can also set it as <code class=\"codespan\">&#39;2&#39;</code>, which indicates that two decimal fractions are reserved.</p>\n","default":"'auto'"},"formatter":{"type":["string","Function"],"description":"<p>The formatter of label.</p>\n<p>If set as <code class=\"codespan\">string</code>, for example it can be: <code class=\"codespan\">formatter: &#39;some text {value} some text</code>, where <code class=\"codespan\">{value}</code> will be replaced by axis value automatically.</p>\n<p>If set as <code class=\"codespan\">function</code>:</p>\n<p><strong>Parameters:</strong></p>\n<p><code class=\"codespan\">{Object}</code> params: Including fields as follows:</p>\n<p><code class=\"codespan\">{Object}</code> params.value: current value of this axis. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;category&#39;</code>, it is one of the value in <code class=\"codespan\">axis.data</code>. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;time&#39;</code>, it is a timestamp.</p>\n<p><code class=\"codespan\">{Array.&lt;Object&gt;}</code> params.seriesData: An array, containing info of nearest points. Each item is:</p>\n<p><code class=\"codespan\">{string}</code> params.axisDimension: The dimension name of the axis. For example, in catesian it will be <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, and in polar it will be <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code>.</p>\n<p><code class=\"codespan\">{number}</code> params.axisIndex: The index of the axis, for example, <code class=\"codespan\">0</code>,<code class=\"codespan\">1</code>, <code class=\"codespan\">2</code>, ...</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>Each item also includes axis infomation:</p>\n<pre><code class=\"lang-js\">{\n    axisDim: &#39;x&#39;, // &#39;x&#39;, &#39;y&#39;, &#39;angle&#39;, &#39;radius&#39;, &#39;single&#39;\n    axisId: &#39;xxx&#39;,\n    axisName: &#39;xxx&#39;,\n    axisIndex: 3,\n    axisValue: 121, // The current value of axisPointer\n    axisValueLabel: &#39;text of value&#39;\n}\n</code></pre>\n<p><strong>Return:</strong></p>\n<p>The string to be displayed.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">formatter: function (params) {\n    // If axis.type is &#39;time&#39;\n    return &#39;some text&#39; + echarts.format.formatTime(params.value);\n}\n</code></pre>\n","default":null},"margin":{"type":["boolean"],"description":"<p>Distance between label and axis.</p>\n","default":3},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"padding":{"type":["string","Array"],"description":"\n\n<p>axisPointer space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":"[5, 7, 5, 7]"},"backgroundColor":{"type":["string"],"description":"<p>Background color of label, the same as <a href=\"#xAxis.axisLine.lineStyle.color\">axis.axisLine.lineStyle.color</a> by default.</p>\n","default":"'auto'"},"borderColor":{"type":["string"],"description":"<p>Border color of label.</p>\n","default":null},"borderWidth":{"type":["string"],"description":"<p>Border width of label.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"lineStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;line&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#555"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"shadowStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;shadow&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'rgba(150,150,150,0.3)"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"triggerTooltip":{"type":["boolean"],"description":"\n\n<p>Whether to trigger tooltip.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"value":{"type":["number"],"description":"<p>current value. When using <a href=\"xAxisPointer.handle\" target=\"_blank\">axisPointer.handle</a>, <code class=\"codespan\">value</code> can be set to define the initail position of axisPointer.</p>\n","default":null},"status":{"type":["boolean"],"description":"\n\n<p>Current status, can be <code class=\"codespan\">&#39;show&#39;</code> 和 <code class=\"codespan\">&#39;hide&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"show,hide"}},"handle":{"type":["Object"],"description":"<p>A button used to drag axisPointer. This feature is applicable in touch device. See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-tooltip-touch&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set to <code class=\"codespan\">true</code> to use handle.</p>\n","uiControl":{"type":"boolean"},"default":false},"icon":{"type":["*"],"description":"\n\n<p>The icon of the handle.</p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/axisPointer-handle-image&amp;edit=1&amp;reset=1\" target=\"_blank\">example of using image</a></p>\n","uiControl":{"type":"icon","clean":"true"}},"size":{"type":["number","Array"],"description":"\n\n<p>The size of the handle, which can be set as a single value or an array (<code class=\"codespan\">[width, height]</code>).</p>\n","uiControl":{"type":"vector","default":"45,45","min":"0","step":"0.5","dims":"width,height"},"default":45},"margin":{"type":["number"],"description":"\n\n<p>Distance from handle center to axis.</p>\n","uiControl":{"type":"number","default":"50","min":"0","step":"0.5"},"default":50},"color":{"type":["string"],"description":"\n\n<p>The color of the handle.</p>\n","uiControl":{"type":"color"},"default":"'#333'"},"throttle":{"type":["number"],"description":"\n\n<p>Throttle rate of trigger view update when dragging handle, in ms. Increase the value to improve performance, but decrease the experience.</p>\n","uiControl":{"type":"number","default":"40","min":"0","step":"10"},"default":40},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"2","step":"0.5"},"default":2},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in y axis.</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in y axis, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":0}}},"polar":{"type":["Object"],"description":"<p>Polar coordinate can be used in scatter and line chart. Every polar coordinate has an <a href=\"#angleAxis\">angleAxis</a> and a <a href=\"#radiusAxis\">radiusAxis</a>.</p>\n<p><strong>For example: </strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-polar-punchCard&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"center":{"type":["Array"],"description":"\n\n<p>Center position of Polar coordinate, the first of which is the horizontal position, and the second is the vertical position.</p>\n<p>Percentage is supported. When set in percentage, the item is relative to the container width, and the second item to the height.</p>\n<p><strong>Example: </strong></p>\n<pre><code>// Set to absolute pixel values\ncenter: [400, 300]\n// Set to relative percent\ncenter: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>","uiControl":{"type":"percentvector","dims":"x,y"},"default":"['50%', '50%']"},"radius":{"type":["number","string","Array"],"description":"\n\n<p>Radius of Polar coordinate. Value can be:</p>\n<ul>\n<li><code class=\"codespan\">number</code>: Specify outside radius directly.</li>\n<li><code class=\"codespan\">string</code>: For example, <code class=\"codespan\">&#39;20%&#39;</code>, means that the outside radius is 20% of the viewport size (the little one between width and height of the chart container).</li>\n</ul>\n<ul>\n<li><code class=\"codespan\">Array.&lt;number|string&gt;</code>: The first item specifies the inside radius, and the second item specifies the outside radius. Each item follows the definitions above.</li>\n</ul>\n","uiControl":{"type":"percentvector","dims":"inner,outer","default":"0%, 75%"}},"tooltip":{"type":["Object"],"description":"<p>tooltip settings in the coordinate system component.</p>\n<hr>\n<p><strong>General Introduction:</strong></p>\n<p>tooltip can be configured on different places:</p>\n<ul>\n<li><p>Configured on global: <a href=\"#tooltip\">tooltip</a></p>\n</li>\n<li><p>Configured in a coordinate system: <a href=\"#grid.tooltip\">grid.tooltip</a>, <a href=\"#polar.tooltip\">polar.tooltip</a>, <a href=\"#single.tooltip\">single.tooltip</a></p>\n</li>\n<li><p>Configured in a series: <a href=\"#series.tooltip\">series.tooltip</a></p>\n</li>\n<li><p>Configured in each item of <code class=\"codespan\">series.data</code>: <a href=\"#series.data.tooltip\">series.data.tooltip</a></p>\n</li>\n</ul>\n<hr>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the tooltip component, including tooltip floating layer and <a href=\"#tooltip.axisPointer\">axisPointer</a>.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"trigger":{"type":["string"],"description":"\n\n<p>Type of triggering.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;item&#39;</code></p>\n<p>  Triggered by data item, which is mainly used for charts that don&#39;t have a category axis like scatter charts or pie charts.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;axis&#39;</code></p>\n<p>  Triggered by axes, which is mainly used for charts that have category axes, like bar charts or line charts.</p>\n<p> ECharts 2.x only supports axis trigger for category axis. In ECharts 3, it is supported for all types of axes in <a href=\"#grid\">grid</a> or <a href=\"#polar\">polar</a>. Also, you may assign axis with <a href=\"#tooltip.axisPointer.axis\">axisPointer.axis</a>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code></p>\n<p>  Trigger nothing.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"item,axis,none","default":"item"},"default":"'item'"},"axisPointer":{"type":["Object"],"description":"<p>Configuration item for axisPointer.</p>\n<p><code class=\"codespan\">tooltip.axisPointer</code> is like syntactic sugar of axisPointer settings on axes (for example, <a href=\"#xAxis.axisPointer\">xAxis.axisPointer</a> or <a href=\"#angleAxis.axisPointer\">angleAxis.axisPointer</a>). More detailed features can be configured on <code class=\"codespan\">someAxis.axisPointer</code>. But in common cases, using <code class=\"codespan\">tooltip.axisPointer</code> is more convenient.</p>\n<blockquote>\n<p><strong>Notice:</strong> configurations of <code class=\"codespan\">tooltip.axisPointer</code> has lower priority than that of <code class=\"codespan\">someAxis.axisPointer</code>.</p>\n</blockquote>\n<hr>\n<p><code class=\"codespan\">axisPointer</code> is a tool for displaying reference line and axis value under mouse pointer.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/candlestick-axisPointer&edit=1&reset=1\" width=\"600\" height=\"450\"></iframe>\n\n\n<p>In the demo above, <a href=\"#axisPointer.link\">axisPointer.link</a> is used to link axisPointer from different coordinate systems.</p>\n<p><code class=\"codespan\">axisPointer</code> can also be used on touch device, where user can drag the button to move the reference line and label.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-tooltip-touch&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n<p>In the cases that more than one axis exist, axisPointer helps to look inside the data.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=multiple-y-axis&edit=1&reset=1\" width=\"600\" height=\"300\"></iframe>\n\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=multiple-x-axis&edit=1&reset=1\" width=\"600\" height=\"300\"></iframe>\n\n\n\n<hr>\n<blockquote>\n<p><strong>Notice:</strong>\nGenerally, axisPointers is configured in each axes who need them (for example <a href=\"#xAxis.axisPointer\">xAxis.axisPointer</a>), or configured in <code class=\"codespan\">tooltip</code> (for example <a href=\"#tooltip.axisPointer\">tooltip.axisPointer</a>).</p>\n</blockquote>\n<blockquote>\n<p>But these configurations can only be configured in global axisPointer:\n<a href=\"#axisPointer.triggerOn\">axisPointer.triggerOn</a>, <a href=\"#axisPointer.link\">axisPointer.link</a>.</p>\n</blockquote>\n<hr>\n<hr>\n<p><strong>How to display axisPointer:</strong></p>\n<p>In <a href=\"#grid\">cartesian (grid)</a> and <a href=\"#single\">polar](~polar) and (single axis</a>, each axis has its own axisPointer.</p>\n<p>Those axisPointer will not be displayed by default, utill configured as follows:</p>\n<ul>\n<li><p>Set <code class=\"codespan\">someAxis.axisPointer.show</code> (like <a href=\"#xAxis.axisPointer.show\">xAxis.axisPointer.show</a>) as <code class=\"codespan\">true</code>. Then axisPointer of this axis will be displayed.</p>\n</li>\n<li><p>Set <a href=\"#tooltip.trigger\">tooltip.trigger</a> as <code class=\"codespan\">&#39;axis&#39;</code>, or set <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> as <code class=\"codespan\">&#39;cross&#39;</code>. Then coordinate system will automatically chose the axes who will display their axisPointers. (<a href=\"#tooltip.axisPointer.axis\">tooltip.axisPointer.axis</a> can be used to change the choice.) Notice, <code class=\"codespan\">axis.axisPointer</code> will override <code class=\"codespan\">tooltip.axisPointer</code> settings.</p>\n</li>\n</ul>\n<hr>\n<p><strong>How to display the label of axisPointer:</strong></p>\n<p>The label of axisPointer will not be displayed by default(namely, only reference line will be displayed by default), utill configured as follows:</p>\n<ul>\n<li><p>Set <code class=\"codespan\">someAxis.axisPointer.label.show</code> (for example <a href=\"#xAxis.axisPointer.show\">xAxis.axisPointer.label.show</a>) as <code class=\"codespan\">true</code>. Then the label of the axisPointer will be displayed.</p>\n</li>\n<li><p>Set <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> as  <code class=\"codespan\">&#39;cross&#39;</code>. Then the label of the crossed axisPointers will be displayed.</p>\n</li>\n</ul>\n<hr>\n<p><strong>How to configure axisPointer on touch device:</strong></p>\n<p>Set <code class=\"codespan\">someAxis.axisPointer.handle.show</code> (for example <a href=\"#xAxis.axisPointer.handle.show\">xAxis.axisPointer.handle.show</a> as <code class=\"codespan\">true</code>. Then the button for dragging will be displayed. (This feature is not supported on polar).</p>\n<p><strong>Notice:</strong>\nIf tooltip does not work well in this case, try to set<a href=\"#tooltip.triggerOn\">tooltip.triggerOn</a> as <code class=\"codespan\">&#39;none&#39;</code> (for the effect: show tooltip when finger holding on the button, and hide tooltip after finger left the button), or set <a href=\"#tooltip.alwaysShowContent\">tooltip.alwaysShowContent</a> as <code class=\"codespan\">true</code> (then tooltip will always be displayed).</p>\n<p>See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-tooltip-touch&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>.</p>\n<hr>\n<p><strong>Snap to point</strong></p>\n<p>In value axis and time axis, if <a href=\"#xAxis.axisPointer.snap\">snap</a> is set as true, axisPointer will snap to point automatically.</p>\n<hr>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Indicator type.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;line&#39;</code> line indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;shadow&#39;</code> shadow crosshair indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code> no indicator displayed.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;cross&#39;</code> crosshair indicator, which is actually the shortcut of enable two axisPointers of two orthometric axes.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"none,line,shadow,cross","default":"line"},"default":"'line'"},"axis":{"type":["string"],"description":"<p>The coordinate axis, which could be <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, <code class=\"codespan\">&#39;radius&#39;</code>, or <code class=\"codespan\">&#39;angle&#39;</code>. By default, each coordinate system will automatically chose the axes whose will display its axisPointer (category axis or time axis is used by default).</p>\n","default":"'auto'"},"snap":{"type":["boolean"],"description":"<p>Whether snap to point automatically. The default value is auto determined.</p>\n<p>This feature usually makes sense in value axis and time axis, where tiny points can be seeked automatically.</p>\n"},"z":{"type":["number"],"description":"<p>z value, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n"},"label":{"type":["Object"],"description":"<p>label of axisPointer</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label. Label will not show by default. But if <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, label will be displayed automatically.</p>\n","default":false},"precision":{"type":["number","string"],"description":"<p>The precision of value in label. It is auto determined by default. You can also set it as <code class=\"codespan\">&#39;2&#39;</code>, which indicates that two decimal fractions are reserved.</p>\n","default":"'auto'"},"formatter":{"type":["string","Function"],"description":"<p>The formatter of label.</p>\n<p>If set as <code class=\"codespan\">string</code>, for example it can be: <code class=\"codespan\">formatter: &#39;some text {value} some text</code>, where <code class=\"codespan\">{value}</code> will be replaced by axis value automatically.</p>\n<p>If set as <code class=\"codespan\">function</code>:</p>\n<p><strong>Parameters:</strong></p>\n<p><code class=\"codespan\">{Object}</code> params: Including fields as follows:</p>\n<p><code class=\"codespan\">{Object}</code> params.value: current value of this axis. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;category&#39;</code>, it is one of the value in <code class=\"codespan\">axis.data</code>. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;time&#39;</code>, it is a timestamp.</p>\n<p><code class=\"codespan\">{Array.&lt;Object&gt;}</code> params.seriesData: An array, containing info of nearest points. Each item is:</p>\n<p><code class=\"codespan\">{string}</code> params.axisDimension: The dimension name of the axis. For example, in catesian it will be <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, and in polar it will be <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code>.</p>\n<p><code class=\"codespan\">{number}</code> params.axisIndex: The index of the axis, for example, <code class=\"codespan\">0</code>,<code class=\"codespan\">1</code>, <code class=\"codespan\">2</code>, ...</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>Each item also includes axis infomation:</p>\n<pre><code class=\"lang-js\">{\n    axisDim: &#39;x&#39;, // &#39;x&#39;, &#39;y&#39;, &#39;angle&#39;, &#39;radius&#39;, &#39;single&#39;\n    axisId: &#39;xxx&#39;,\n    axisName: &#39;xxx&#39;,\n    axisIndex: 3,\n    axisValue: 121, // The current value of axisPointer\n    axisValueLabel: &#39;text of value&#39;\n}\n</code></pre>\n<p><strong>Return:</strong></p>\n<p>The string to be displayed.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">formatter: function (params) {\n    // If axis.type is &#39;time&#39;\n    return &#39;some text&#39; + echarts.format.formatTime(params.value);\n}\n</code></pre>\n","default":null},"margin":{"type":["boolean"],"description":"<p>Distance between label and axis.</p>\n","default":3},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"padding":{"type":["string","Array"],"description":"\n\n<p>axisPointer space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":"[5, 7, 5, 7]"},"backgroundColor":{"type":["string"],"description":"<p>Background color of label, the same as <a href=\"#xAxis.axisLine.lineStyle.color\">axis.axisLine.lineStyle.color</a> by default.</p>\n","default":"'auto'"},"borderColor":{"type":["string"],"description":"<p>Border color of label.</p>\n","default":null},"borderWidth":{"type":["string"],"description":"<p>Border width of label.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"lineStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;line&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#555"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"shadowStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;shadow&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'rgba(150,150,150,0.3)"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"crossStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;cross&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#555"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"dashed"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":200},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"exponentialOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"position":{"type":["string","Array"],"description":"<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n\n\n\n\n\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n\n\n\n\n\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n\n\n\n\n\n\n\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},"radiusAxis":{"type":["Object"],"description":"<p>Radial axis of polar coordinate.</p>\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"polarIndex":{"type":["number"],"description":"<p>Index of radial axis in polor coordinate. It&#39;s the first axis by default.</p>\n","default":0},"type":{"type":["string"],"description":"<p>Type of axis.</p>\n<p>Option:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;value&#39;</code>\n  Numerical axis, suitable for continuous data.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;category&#39;</code>\n  Category axis, suitable for discrete category data. Category data can be auto retrieved from <a href=\"#series.data\">series.data</a> or <a href=\"#dataset.source\">dataset.source</a>, or can be specified via <a href=\"#radiusAxis.data\">radiusAxis.data</a>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;time&#39;</code>\n  Time axis, suitable for continuous time series data. As compared to value axis, it has a better formatting for time and a different tick calculation method. For example, it decides to use month, week, day or hour for tick based on the range of span.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;log&#39;</code>\n  Log axis, suitable for log data.</p>\n</li>\n</ul>\n","default":"'value'"},"name":{"type":["string"],"description":"\n\n<p>Name of axis.</p>\n","uiControl":{"type":"text"}},"nameLocation":{"type":["string"],"description":"\n\n<p>Location of axis name.</p>\n<p><strong>Options: </strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> or <code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","options":"start,middle,end","default":"end"},"default":"'end'"},"nameTextStyle":{"type":["Object"],"description":"<p>Text style of axis name.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Color of axis name uses <a href=\"#radiusAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default.</p>\n","uiControl":{"type":"color"}},"fontStyle":{"type":["string"],"description":"\n\n<p>axis name font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p>axis name font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p>axis name font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p>axis name font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"nameGap":{"type":["number"],"description":"\n\n<p>Gap between axis name and axis line.</p>\n","uiControl":{"type":"number","step":"0.5","default":"15"},"default":15},"nameRotate":{"type":["number"],"description":"\n\n<p>Rotation of axis name.</p>\n","uiControl":{"type":"angle","min":"-360","max":"360","step":"1"},"default":null},"inverse":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> to invert the axis.\nThis is a new option available from Echarts 3 and newer.</p>\n","uiControl":{"type":"boolean"},"default":false},"boundaryGap":{"type":["boolean","Array"],"description":"\n\n<p>The boundary gap on both sides of a coordinate axis. The setting and behavior of category axes and non-category axes are different.</p>\n<p>The <code class=\"codespan\">boundaryGap</code> of category axis can be set to either <code class=\"codespan\">true</code> or <code class=\"codespan\">false</code>. Default value is set to be <code class=\"codespan\">true</code>, in which case <a href=\"#radiusAxis.axisTick\">axisTick</a> is served only as a separation line, and labels and data appear only in the center part of two <a href=\"#radiusAxis.axisTick\">axis ticks</a>, which is called <em>band</em>.</p>\n<p>For non-category axis, including time, numerical value, and log axes, <code class=\"codespan\">boundaryGap</code> is an array of two values, representing the spanning range between minimum and maximum value. The value can be set in numeric value or relative percentage, which becomes invalid after setting <a href=\"#radiusAxis.min\">min</a> and <a href=\"#radiusAxis.max\">max</a>.\n<strong>Example: </strong></p>\n<pre><code class=\"lang-js\">boundaryGap: [&#39;20%&#39;, &#39;20%&#39;]\n</code></pre>\n","uiControl":{"type":"boolean"}},"min":{"type":["number","string","Function"],"description":"\n\n<p>The minimun value of axis.</p>\n<p>It can be set to a special value <code class=\"codespan\">&#39;dataMin&#39;</code> so that the minimum value on this axis is set to be the minimum label.</p>\n<p>It will be automatically computed to make sure axis tick is equally distributed when not set.</p>\n<p>In category axis, it can also be set as the ordinal number. For example, if a catergory axis has <code class=\"codespan\">data: [&#39;categoryA&#39;, &#39;categoryB&#39;, &#39;categoryC&#39;]</code>, and the ordinal <code class=\"codespan\">2</code> represents <code class=\"codespan\">&#39;categoryC&#39;</code>. Moreover, it can be set as negative number, like <code class=\"codespan\">-3</code>.</p>\n<p>If <code class=\"codespan\">min</code> is specified as a function, it should return a min value, like:</p>\n<pre><code class=\"lang-js\">min: function (value) {\n    return value.min - 20;\n}\n</code></pre>\n<p><code class=\"codespan\">value</code> is an object, containing the <code class=\"codespan\">min</code> value and <code class=\"codespan\">max</code> value of the data. This function should return the min value of axis, or return <code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> to make echarts use the auto calculated min value (<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> return is only supported since <code class=\"codespan\">v4.8.0</code>).</p>\n","uiControl":{"type":"number"},"default":null},"max":{"type":["number","string","Function"],"description":"\n\n<p>The maximum value of axis.</p>\n<p>It can be set to a special value <code class=\"codespan\">&#39;dataMax&#39;</code> so that the minimum value on this axis is set to be the maximum label.</p>\n<p>It will be automatically computed to make sure axis tick is equally distributed when not set.</p>\n<p>In category axis, it can also be set as the ordinal number. For example, if a catergory axis has <code class=\"codespan\">data: [&#39;categoryA&#39;, &#39;categoryB&#39;, &#39;categoryC&#39;]</code>, and the ordinal <code class=\"codespan\">2</code> represents <code class=\"codespan\">&#39;categoryC&#39;</code>. Moreover, it can be set as negative number, like <code class=\"codespan\">-3</code>.</p>\n<p>If <code class=\"codespan\">max</code> is specified as a function, it should return a max value, like:</p>\n<pre><code class=\"lang-js\">max: function (value) {\n    return value.max - 20;\n}\n</code></pre>\n<p><code class=\"codespan\">value</code> is an object, containing the <code class=\"codespan\">min</code> value and <code class=\"codespan\">max</code> value of the data. This function should return the max value of axis, or return <code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> to make echarts use the auto calculated max value (<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> return is only supported since <code class=\"codespan\">v4.8.0</code>).</p>\n","uiControl":{"type":"number"},"default":null},"scale":{"type":["boolean"],"description":"\n\n<p>It is available only in numerical axis, i.e., <a href=\"#radiusAxis.type\">type</a>: &#39;value&#39;.</p>\n<p>It specifies whether not to contain zero position of axis compulsively. When it is set to be <code class=\"codespan\">true</code>, the axis may not contain zero position, which is useful in the scatter chart for both value axes.</p>\n<p>This configuration item is unavailable when the <a href=\"#radiusAxis.min\">min</a> and <a href=\"#radiusAxis.max\">max</a> are set.</p>\n","uiControl":{"type":"boolean"},"default":false},"splitNumber":{"type":["number"],"description":"\n\n<p>Number of segments that the axis is split into. Note that this number serves only as a recommendation, and the true segments may be adjusted based on readability.</p>\n<p>This is unavailable for category axis.</p>\n","uiControl":{"type":"number","min":"1","step":"1","default":"5"},"default":5},"minInterval":{"type":["number"],"description":"\n\n<p>Minimum gap between split lines.</p>\n<p>For example, it can be set to be <code class=\"codespan\">1</code> to make sure axis label is show as integer.</p>\n<pre><code class=\"lang-js\">{\n    minInterval: 1\n}\n</code></pre>\n<p>It is available only for axis of <a href=\"#radiusAxis.type\">type</a> &#39;value&#39; or &#39;time&#39;.</p>\n","uiControl":{"type":"number"},"default":0},"maxInterval":{"type":["number"],"description":"\n\n<p>Maximum gap between split lines.</p>\n<p>For example, in time axis (<a href=\"#radiusAxis.type\">type</a> is &#39;time&#39;), it can be set to be <code class=\"codespan\">3600 * 24 * 1000</code> to make sure that the gap between axis labels is less than or equal to one day.</p>\n<pre><code class=\"lang-js\">{\n    maxInterval: 3600 * 1000 * 24\n}\n</code></pre>\n<p>It is available only for axis of <a href=\"#radiusAxis.type\">type</a> &#39;value&#39; or &#39;time&#39;.</p>\n","uiControl":{"type":"number"}},"interval":{"type":["number"],"description":"\n\n<p>Compulsively set segmentation interval for axis.</p>\n<p>As <a href=\"#radiusAxis.splitNumber\">splitNumber</a> is a recommendation value, the calculated tick may not be the same as expected. In this case, interval should be used along with <a href=\"#radiusAxis.min\">min</a> and <a href=\"#radiusAxis.max\">max</a> to compulsively set tickings. But in most cases, we do not suggest using this, out automatic calculation is enough for most situations.</p>\n<p>This is unavailable for category axis. Timestamp should be passed for <a href=\"#radiusAxis.type\">type</a>: &#39;time&#39; axis. Logged value should be passed for <a href=\"#radiusAxis.type\">type</a>: &#39;log&#39; axis.</p>\n","uiControl":{"type":"number"}},"logBase":{"type":["number"],"description":"\n\n<p>Base of logarithm, which is valid only for numeric axes with <a href=\"#radiusAxis.type\">type</a>: &#39;log&#39;.</p>\n","uiControl":{"type":"number","default":"10"},"default":10},"silent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code>, to prevent interaction with the axis.</p>\n","default":false},"triggerEvent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code> to enable triggering events.</p>\n<p>Parameters of the event include:</p>\n<pre><code class=\"lang-js\">{\n    // Component type: xAxis, yAxis, radiusAxis, angleAxis\n    // Each of which has an attribute for index, e.g., xAxisIndex for xAxis\n    componentType: string,\n    // Value on axis before being formatted.\n    // Click on value label to trigger event.\n    value: &#39;&#39;,\n    // Name of axis.\n    // Click on laben name to trigger event.\n    name: &#39;&#39;\n}\n</code></pre>\n","default":false},"axisLine":{"type":["Object"],"description":"<p>Settings related to axis line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis line from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"symbol":{"type":["string","Array"],"description":"\n\n<p>Symbol of the two ends of the axis. It could be a string, representing the same symbol for two ends; or an array with two string elements, representing the two ends separately. It&#39;s set to be <code class=\"codespan\">&#39;none&#39;</code> by default, meaning no arrow for either end. If it is set to be <code class=\"codespan\">&#39;arrow&#39;</code>, there shall be two arrows. If there should only one arrow at the end, it should set to be <code class=\"codespan\">[&#39;none&#39;, &#39;arrow&#39;]</code>.</p>\n","uiControl":{"type":"icon","default":"none"},"default":"'none'"},"symbolSize":{"type":["Array"],"description":"\n\n<p>Size of the arrows at two ends. The first is the width perpendicular to the axis, the next is the width parallel to the axis.</p>\n","uiControl":{"type":"vector","default":"10,15"},"default":"[10, 15]"},"symbolOffset":{"type":["Array","number"],"description":"\n\n<p>Arrow offset of axis. If is array, the first number is the offset of the arrow at the beginning, and the second number is the offset of the arrow at the end. If is number, it means the arrows have the same offset.</p>\n","uiControl":{"type":"vector","default":"0,0"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>line styleLine color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#333'"},"width":{"type":["number"],"description":"\n\n<p>line style line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>line style line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisTick":{"type":["Object"],"description":"<p>Settings related to axis tick.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis tick from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"alignWithLabel":{"type":["boolean"],"description":"\n\n<p>Align axis tick with label, which is available only when <code class=\"codespan\">boundaryGap</code> is set to be <code class=\"codespan\">true</code> in category axis. See the following picture:</p>\n<p><img width=\"600\" height=\"auto\" src=\"documents/asset/img/axis-align-with-label.png\"></p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of axisTick, which is available in category axis.  is set to be the same as <a href=\"#radiusAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"inside":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> so the axis labels face the <code class=\"codespan\">inside</code> direction.</p>\n","uiControl":{"type":"boolean"},"default":false},"length":{"type":["number"],"description":"\n\n<p>The length of the axis tick.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"5"},"default":5},"lineStyle":{"type":["Object"],"description":"<p>Line style of axis ticks.</p>\n","properties":{"color":{"type":["Color"],"description":"<p>Color of axis label is set to be <a href=\"#radiusAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default.</p>\n"},"width":{"type":["number"],"description":"\n\n<p>axisTick line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>axisTick line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"minorTick":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.6.0</code></p>\n</blockquote>\n<p>Settings related minor ticks.</p>\n<p>Note: <code class=\"codespan\">minorTick</code> is not available in the <code class=\"codespan\">category</code> type axis.</p>\n<p>Examples:</p>\n<p>1) Using minor ticks in function plotting.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-function&edit=1&reset=1\" width=\"600\" height=\"350\"></iframe>\n\n\n<p>2) Using minor ticks in log axis.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-log&edit=1&reset=1\" width=\"600\" height=\"350\"></iframe>\n\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>If show minor ticks.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"splitNumber":{"type":["number"],"description":"\n\n<p>Number of interval splited by minor ticks.</p>\n","uiControl":{"type":"number","min":"1","step":"1","default":"5"},"default":5},"length":{"type":["number"],"description":"\n\n<p>Length of minor ticks lines。</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"3"},"default":3},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Style configuration of minor ticks lines <a href=\"#radiusAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a>。</p>\n","uiControl":{"type":"color"}},"width":{"type":["number"],"description":"\n\n<p>minorTick line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>minorTick line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisLabel":{"type":["Object"],"description":"<p>Settings related to axis label.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis label from appearing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis label, which is available in category axis. </p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"inside":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> so the axis labels face the <code class=\"codespan\">inside</code> direction.</p>\n","uiControl":{"type":"boolean"},"default":false},"rotate":{"type":["number"],"description":"\n\n<p>Rotation degree of axis label, which is especially useful when there is no enough space for category axis.</p>\n<p>Rotation degree is from -90 to 90.</p>\n","uiControl":{"type":"angle","min":"-90","max":"90","step":"1"},"default":0},"margin":{"type":["number"],"description":"\n\n<p>The margin between the axis label and the axis line.</p>\n","uiControl":{"type":"number","default":"8","step":"0.5"},"default":8},"formatter":{"type":["string","Function"],"description":"<p>Formatter of axis label, which supports string template and callback function.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use string template; template variable is the default label of axis {value}\nformatter: &#39;{value} kg&#39;\n// Use callback.\nformatter: function (value, index) {\n    return value + &#39;kg&#39;;\n}\n</code></pre>\n<hr>\n<p>For axes of time <a href=\"#.type\">type</a>: <code class=\"codespan\">&#39;time&#39;</code>, <code class=\"codespan\">formatter</code> supports the following forms:</p>\n<ul>\n<li><strong>String Templates</strong>: an easy and fast way to make frequently used date/time template, formed in <code class=\"codespan\">string</code></li>\n<li><strong>Callback Functions</strong>: customized formatter to make complex format, formed in <code class=\"codespan\">Function</code></li>\n<li><strong>Cascading Templates</strong>: to adopt different formatters for different time granularity, formed in <code class=\"codespan\">object</code></li>\n</ul>\n<p>Next, we are going to introduce these three forms one by one.</p>\n<p><strong> String Templates </strong></p>\n<p>Using string templates is an easy way to format date/time with frequently used formats. If it can be used to make what you want, you are advised to do so. If not, you could then consider the others. Supported formats are:</p>\n<table>\n<thead>\n<tr>\n<th>Group</th>\n<th>Template</th>\n<th>Value (EN)</th>\n<th>Value (ZH)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Year</td>\n<td>{yyyy}</td>\n<td>e.g., 2020, 2021, ...</td>\n<td>例：2020, 2021, ...</td>\n</tr>\n<tr>\n<td></td>\n<td>{yy}</td>\n<td>00-99</td>\n<td>00-99</td>\n</tr>\n<tr>\n<td>Quarter</td>\n<td>{Q}</td>\n<td>1, 2, 3, 4</td>\n<td>1, 2, 3, 4</td>\n</tr>\n<tr>\n<td>Month</td>\n<td>{MMMM}</td>\n<td>e.g., January, February, ...</td>\n<td>一月、二月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MMM}</td>\n<td>e.g., Jan, Feb, ...</td>\n<td>1月、2月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MM}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{M}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Day of Month</td>\n<td>{dd}</td>\n<td>01-31</td>\n<td>01-31</td>\n</tr>\n<tr>\n<td></td>\n<td>{d}</td>\n<td>1-31</td>\n<td>1-31</td>\n</tr>\n<tr>\n<td>Day of Week</td>\n<td>{eeee}</td>\n<td>Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday</td>\n<td>星期日、星期一、星期二、星期三、星期四、星期五、星期六</td>\n</tr>\n<tr>\n<td></td>\n<td>{ee}</td>\n<td>Sun, Mon, Tues, Wed, Thu, Fri, Sat</td>\n<td>日、一、二、三、四、五、六</td>\n</tr>\n<tr>\n<td></td>\n<td>{e}</td>\n<td>1-54</td>\n<td>1-54</td>\n</tr>\n<tr>\n<td>Hour</td>\n<td>{HH}</td>\n<td>00-23</td>\n<td>00-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{H}</td>\n<td>0-23</td>\n<td>0-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{hh}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{h}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Minute</td>\n<td>{mm}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{m}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Second</td>\n<td>{ss}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{s}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Millisecond</td>\n<td>{SSS}</td>\n<td>000-999</td>\n<td>000-999</td>\n</tr>\n<tr>\n<td></td>\n<td>{S}</td>\n<td>0-999</td>\n<td>0-999</td>\n</tr>\n</tbody>\n</table>\n<blockquote>\n<p>Templates of other languages can be found in <a href=\"https://github.com/apache/echarts/tree/master/src/i18n\" target=\"_blank\">the language package</a>. Please refer to <a href=\"api.html#echarts.registerLocale\" target=\"_blank\">echarts.registerLocale</a> to register a language.</p>\n</blockquote>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: &#39;{yyyy}-{MM}-{dd}&#39; // gets labels like &#39;2020-12-02&#39;\nformatter: &#39;Day {d}&#39; // gets labels like &#39;Day 2&#39;\n</code></pre>\n<p><strong> Callback Functions </strong></p>\n<p>Callback functions can be used to get different formats for different axis tick values. Sometimes, if you have complex date/time formatting requirement, third-party libraries like <a href=\"https://momentjs.com/\" target=\"_blank\">Moment.js</a> or <a href=\"https://date-fns.org/\" target=\"_blank\">date-fns</a> can be used to return formatted labels.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use callback function; function parameters are axis index\nformatter: function (value, index) {\n    // Formatted to be month/day; display year only in the first label\n    var date = new Date(value);\n    var texts = [(date.getMonth() + 1), date.getDate()];\n    if (idx === 0) {\n        texts.unshift(date.getYear());\n    }\n    return texts.join(&#39;/&#39;);\n}\n</code></pre>\n<p><strong> Cascading Templates </strong></p>\n<p>Sometimes, we wish to use different formats for different time granularity. For example, in a quarter-year chart, we may wish to see the month name with the first date of the month, while see the date name with others. This can be made with:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: {\n    month: &#39;{MMMM}&#39;, // Jan, Feb, ...\n    day: &#39;{d}&#39; // 1, 2, ...\n}\n</code></pre>\n<p>Supported levels and their default formatters are:</p>\n<pre><code class=\"lang-js\">{\n    year: &#39;{yyyy}&#39;,\n    month: &#39;{MMM}&#39;,\n    day: &#39;{d}&#39;,\n    hour: &#39;{HH}:{mm}&#39;,\n    minute: &#39;{HH}:{mm}&#39;,\n    second: &#39;{HH}:{mm}:{ss}&#39;,\n    millisecond: &#39;{hh}:{mm}:{ss} {SSS}&#39;,\n    none: &#39;{yyyy}-{MM}-{dd} {hh}:{mm}:{ss} {SSS}&#39;\n}\n</code></pre>\n<p>Let&#39;s take <code class=\"codespan\">day</code> for example. When a tick value is <code class=\"codespan\">0</code> for its hour, minute, second, and millisecond, <code class=\"codespan\">day</code> level will be used to make formatter. <code class=\"codespan\">none</code> is used when no other level fulfills, which is for tick values with millisecond values other than <code class=\"codespan\">0</code>.</p>\n<p><strong> Rich Text </strong></p>\n<p>The above three forms all support rich text, so it can be used to make some complex effects.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: {\n            // Display year and month information on the first data of a year\n            year: &#39;{yearStyle|{yyyy}}\\n{monthStyle|{MMM}}&#39;,\n            month: &#39;{monthStyle|{MMM}}&#39;\n        },\n        rich: {\n            yearStyle: {\n                // Make yearly text more standing out\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            monthStyle: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n<p>The above example can also be made with a callback function:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: function (value) {\n            const date = new Date(value);\n            const yearStart = new Date(value);\n            yearStart.setMonth(0);\n            yearStart.setDate(1);\n            yearStart.setHours(0);\n            yearStart.setMinutes(0);\n            yearStart.setSeconds(0);\n            yearStart.setMilliseconds(0);\n            // Whether a tick value is the start of a year\n            if (date.getTime() === yearStart.getTime()) {\n                return &#39;{year|&#39; + date.getFullYear() + &#39;}\\n&#39;\n                    + &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;;\n            }\n            else {\n                return &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;\n            }\n        },\n        rich: {\n            year: {\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            month: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n","default":null},"showMinLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the min tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the min tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"showMaxLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the max tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the max tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"color":{"type":["Color","Function"],"description":"\n\n<p>Color of axis label is set to be <a href=\"#radiusAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default. Callback function is supported, in the following format:</p>\n<pre><code class=\"lang-js\">(val: string) =&gt; Color\n</code></pre>\n<p>Parameter is the text of label, and return value is the color. See the following example:</p>\n<pre><code class=\"lang-js\">textStyle: {\n    color: function (value, index) {\n        return value &gt;= 0 ? &#39;green&#39; : &#39;red&#39;;\n    }\n}\n</code></pre>\n","uiControl":{"type":"color"}},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"splitLine":{"type":["Object"],"description":"<p>Split line of axis in <a href=\"#grid\">grid</a> area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the splitLine from showing.\n<code class=\"codespan\">value</code> type axes are shown by default, while <code class=\"codespan\">category</code> type axes are hidden.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis splitLine, which is available in category axis.  is set to be the same as <a href=\"#radiusAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Array","string"],"description":"\n\n<p>The color of the splitLine, which could be set separately.</p>\n<p>SplitLine color could also be set in color array, which the split lines would take as their colors in turns.</p>\n<p>Example:</p>\n<pre><code>splitLine: {\n    lineStyle: {\n        // Dark and light colors will be used in turns\n        color: [&#39;#aaa&#39;, &#39;#ddd&#39;]\n    }\n}\n</code></pre>","uiControl":{"type":"color"},"default":"['#ccc']"},"width":{"type":["number"],"description":"\n\n<p>splitLine line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>splitLine line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"minorSplitLine":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.6.0</code></p>\n</blockquote>\n<p>Minor split lines of axis in the <a href=\"#grid\">grid</a> area。It will align to the <a href=\"#radiusAxis.minorTick\">minorTick</a></p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>If show minor split lines.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>minorSplitLineLine color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#eee'"},"width":{"type":["number"],"description":"\n\n<p>minorSplitLine line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>minorSplitLine line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"splitArea":{"type":["Object"],"description":"<p>Split area of axis in <a href=\"#grid\">grid</a> area, not shown by default.</p>\n","properties":{"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis splitArea, which is available in category axis.  is set to be the same as <a href=\"#radiusAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> to show the splitArea.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"areaStyle":{"type":["Object"],"description":"<p>Split area style.</p>\n","properties":{"color":{"type":["Array"],"description":"<p>Color of split area.\nSplitArea color could also be set in color array, which the split lines would take as their colors in turns. Dark and light colors in turns are used by default.</p>\n","default":"['rgba(250,250,250,0.3)','rgba(200,200,200,0.3)']"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Category data, available in <a href=\"#radiusAxis.type\">type</a>: &#39;category&#39; axis.</p>\n<p>If <a href=\"#radiusAxis.type\">type</a> is not specified, but <code class=\"codespan\">axis.data</code> is specified, the <a href=\"#radiusAxis.type\">type</a> is auto set as <code class=\"codespan\">&#39;category&#39;</code>.</p>\n<p>If <a href=\"#radiusAxis.type\">type</a> is specified as <code class=\"codespan\">&#39;category&#39;</code>, but <code class=\"codespan\">axis.data</code> is not specified, <code class=\"codespan\">axis.data</code> will be auto collected from <a href=\"#series.data\">series.data</a>. It brings convenience, but we should notice that <code class=\"codespan\">axis.data</code> provides then value range of the <code class=\"codespan\">&#39;category&#39;</code> axis. If  it is auto collected from <a href=\"#series.data\">series.data</a>, Only the values appearing in <a href=\"#series.data\">series.data</a> can be collected. For example, if <a href=\"#series.data\">series.data</a> is empty, nothing will be collected.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Name list of all categories\ndata: [&#39;Monday&#39;, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;, &#39;Friday&#39;, &#39;Saturday&#39;, &#39;Sunday&#39;]\n// Each item could also be a specific configuration item.\n// In this case, `value` is used as the category name.\ndata: [{\n    value: &#39;Monday&#39;,\n    // Highlight Monday\n    textStyle: {\n        fontSize: 20,\n        color: &#39;red&#39;\n    }\n}, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;, &#39;Friday&#39;, &#39;Saturday&#39;, &#39;Sunday&#39;]\n</code></pre>\n","items":{"type":"Object","properties":{"value":{"type":["string"],"description":"<p>Name of a category.</p>\n"},"textStyle":{"type":["Object"],"description":"<p>Text style of the category.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}},"axisPointer":{"type":["Object"],"description":"<p>axisPointer settings on the axis.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>axisPointer will not be displayed by default. But if <a href=\"#tooltip.trigger\">tooltip.trigger</a> is set as <code class=\"codespan\">&#39;axis&#39;</code> or <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, axisPointer will be displayed automatically. Each coordinate system will automatically chose the axes whose will display its axisPointer. <a href=\"#tooltip.axisPointer.axis\">tooltip.axisPointer.axis</a> can be used to change the choice.</p>\n","uiControl":{"type":"boolean"},"default":false},"type":{"type":["string"],"description":"\n\n<p>Indicator type.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;line&#39;</code> line indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;shadow&#39;</code> shadow crosshair indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code> no indicator displayed.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"line,shadow,none"},"default":"'line'"},"snap":{"type":["boolean"],"description":"<p>Whether snap to point automatically. The default value is auto determined.</p>\n<p>This feature usually makes sense in value axis and time axis, where tiny points can be seeked automatically.</p>\n"},"z":{"type":["number"],"description":"<p>z value, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n"},"label":{"type":["Object"],"description":"<p>label of axisPointer</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label. Label will not show by default. But if <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, label will be displayed automatically.</p>\n","default":false},"precision":{"type":["number","string"],"description":"<p>The precision of value in label. It is auto determined by default. You can also set it as <code class=\"codespan\">&#39;2&#39;</code>, which indicates that two decimal fractions are reserved.</p>\n","default":"'auto'"},"formatter":{"type":["string","Function"],"description":"<p>The formatter of label.</p>\n<p>If set as <code class=\"codespan\">string</code>, for example it can be: <code class=\"codespan\">formatter: &#39;some text {value} some text</code>, where <code class=\"codespan\">{value}</code> will be replaced by axis value automatically.</p>\n<p>If set as <code class=\"codespan\">function</code>:</p>\n<p><strong>Parameters:</strong></p>\n<p><code class=\"codespan\">{Object}</code> params: Including fields as follows:</p>\n<p><code class=\"codespan\">{Object}</code> params.value: current value of this axis. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;category&#39;</code>, it is one of the value in <code class=\"codespan\">axis.data</code>. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;time&#39;</code>, it is a timestamp.</p>\n<p><code class=\"codespan\">{Array.&lt;Object&gt;}</code> params.seriesData: An array, containing info of nearest points. Each item is:</p>\n<p><code class=\"codespan\">{string}</code> params.axisDimension: The dimension name of the axis. For example, in catesian it will be <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, and in polar it will be <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code>.</p>\n<p><code class=\"codespan\">{number}</code> params.axisIndex: The index of the axis, for example, <code class=\"codespan\">0</code>,<code class=\"codespan\">1</code>, <code class=\"codespan\">2</code>, ...</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>Each item also includes axis infomation:</p>\n<pre><code class=\"lang-js\">{\n    axisDim: &#39;x&#39;, // &#39;x&#39;, &#39;y&#39;, &#39;angle&#39;, &#39;radius&#39;, &#39;single&#39;\n    axisId: &#39;xxx&#39;,\n    axisName: &#39;xxx&#39;,\n    axisIndex: 3,\n    axisValue: 121, // The current value of axisPointer\n    axisValueLabel: &#39;text of value&#39;\n}\n</code></pre>\n<p><strong>Return:</strong></p>\n<p>The string to be displayed.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">formatter: function (params) {\n    // If axis.type is &#39;time&#39;\n    return &#39;some text&#39; + echarts.format.formatTime(params.value);\n}\n</code></pre>\n","default":null},"margin":{"type":["boolean"],"description":"<p>Distance between label and axis.</p>\n","default":3},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"padding":{"type":["string","Array"],"description":"\n\n<p>axisPointer space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":"[5, 7, 5, 7]"},"backgroundColor":{"type":["string"],"description":"<p>Background color of label, the same as <a href=\"#xAxis.axisLine.lineStyle.color\">axis.axisLine.lineStyle.color</a> by default.</p>\n","default":"'auto'"},"borderColor":{"type":["string"],"description":"<p>Border color of label.</p>\n","default":null},"borderWidth":{"type":["string"],"description":"<p>Border width of label.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"lineStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;line&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#555"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"shadowStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;shadow&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'rgba(150,150,150,0.3)"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"triggerTooltip":{"type":["boolean"],"description":"\n\n<p>Whether to trigger tooltip.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"value":{"type":["number"],"description":"<p>current value. When using <a href=\"xAxisPointer.handle\" target=\"_blank\">axisPointer.handle</a>, <code class=\"codespan\">value</code> can be set to define the initail position of axisPointer.</p>\n","default":null},"status":{"type":["boolean"],"description":"\n\n<p>Current status, can be <code class=\"codespan\">&#39;show&#39;</code> 和 <code class=\"codespan\">&#39;hide&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"show,hide"}},"handle":{"type":["Object"],"description":"<p>A button used to drag axisPointer. This feature is applicable in touch device. See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-tooltip-touch&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set to <code class=\"codespan\">true</code> to use handle.</p>\n","uiControl":{"type":"boolean"},"default":false},"icon":{"type":["*"],"description":"\n\n<p>The icon of the handle.</p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/axisPointer-handle-image&amp;edit=1&amp;reset=1\" target=\"_blank\">example of using image</a></p>\n","uiControl":{"type":"icon","clean":"true"}},"size":{"type":["number","Array"],"description":"\n\n<p>The size of the handle, which can be set as a single value or an array (<code class=\"codespan\">[width, height]</code>).</p>\n","uiControl":{"type":"vector","default":"45,45","min":"0","step":"0.5","dims":"width,height"},"default":45},"margin":{"type":["number"],"description":"\n\n<p>Distance from handle center to axis.</p>\n","uiControl":{"type":"number","default":"50","min":"0","step":"0.5"},"default":50},"color":{"type":["string"],"description":"\n\n<p>The color of the handle.</p>\n","uiControl":{"type":"color"},"default":"'#333'"},"throttle":{"type":["number"],"description":"\n\n<p>Throttle rate of trigger view update when dragging handle, in ms. Increase the value to improve performance, but decrease the experience.</p>\n","uiControl":{"type":"number","default":"40","min":"0","step":"10"},"default":40},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"2","step":"0.5"},"default":2},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in Radial axis.</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in Radial axis, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":0}}},"angleAxis":{"type":["Object"],"description":"<p>The angle axis in Polar Coordinate.</p>\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"polarIndex":{"type":["number"],"description":"<p>The index of angle axis in Polar Coordinate. The first axis is used by default.</p>\n","default":0},"startAngle":{"type":["number"],"description":"\n\n<p>Starting angle of axis. 90 degrees by default, standing for top position of center. 0 degree stands for right position of center.</p>\n<p>The following shows an example with startAngle of 45 deg.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/polar-start-angle&edit=1&reset=1\" width=\"400\" height=\"400\"></iframe>\n\n","uiControl":{"type":"angle","default":"90","min":"-360","max":"360","step":"1"},"default":90},"clockwise":{"type":["boolean"],"description":"\n\n<p>Whether the positive position of axis is clockwise. True for clockwise by default.</p>\n<p>The following shows an example with clockwise as <code class=\"codespan\">false</code>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/polar-anticlockwise&edit=1&reset=1\" width=\"400\" height=\"400\"></iframe>\n\n\n\n","uiControl":{"type":"boolean","default":"true"},"default":true},"type":{"type":["string"],"description":"<p>Type of axis.</p>\n<p>Option:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;value&#39;</code>\n  Numerical axis, suitable for continuous data.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;category&#39;</code>\n  Category axis, suitable for discrete category data. Category data can be auto retrieved from <a href=\"#series.data\">series.data</a> or <a href=\"#dataset.source\">dataset.source</a>, or can be specified via <a href=\"#angleAxis.data\">angleAxis.data</a>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;time&#39;</code>\n  Time axis, suitable for continuous time series data. As compared to value axis, it has a better formatting for time and a different tick calculation method. For example, it decides to use month, week, day or hour for tick based on the range of span.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;log&#39;</code>\n  Log axis, suitable for log data.</p>\n</li>\n</ul>\n","default":"'category'"},"boundaryGap":{"type":["boolean","Array"],"description":"\n\n<p>The boundary gap on both sides of a coordinate axis. The setting and behavior of category axes and non-category axes are different.</p>\n<p>The <code class=\"codespan\">boundaryGap</code> of category axis can be set to either <code class=\"codespan\">true</code> or <code class=\"codespan\">false</code>. Default value is set to be <code class=\"codespan\">true</code>, in which case <a href=\"#angleAxis.axisTick\">axisTick</a> is served only as a separation line, and labels and data appear only in the center part of two <a href=\"#angleAxis.axisTick\">axis ticks</a>, which is called <em>band</em>.</p>\n<p>For non-category axis, including time, numerical value, and log axes, <code class=\"codespan\">boundaryGap</code> is an array of two values, representing the spanning range between minimum and maximum value. The value can be set in numeric value or relative percentage, which becomes invalid after setting <a href=\"#angleAxis.min\">min</a> and <a href=\"#angleAxis.max\">max</a>.\n<strong>Example: </strong></p>\n<pre><code class=\"lang-js\">boundaryGap: [&#39;20%&#39;, &#39;20%&#39;]\n</code></pre>\n","uiControl":{"type":"boolean"}},"min":{"type":["number","string","Function"],"description":"\n\n<p>The minimun value of axis.</p>\n<p>It can be set to a special value <code class=\"codespan\">&#39;dataMin&#39;</code> so that the minimum value on this axis is set to be the minimum label.</p>\n<p>It will be automatically computed to make sure axis tick is equally distributed when not set.</p>\n<p>In category axis, it can also be set as the ordinal number. For example, if a catergory axis has <code class=\"codespan\">data: [&#39;categoryA&#39;, &#39;categoryB&#39;, &#39;categoryC&#39;]</code>, and the ordinal <code class=\"codespan\">2</code> represents <code class=\"codespan\">&#39;categoryC&#39;</code>. Moreover, it can be set as negative number, like <code class=\"codespan\">-3</code>.</p>\n<p>If <code class=\"codespan\">min</code> is specified as a function, it should return a min value, like:</p>\n<pre><code class=\"lang-js\">min: function (value) {\n    return value.min - 20;\n}\n</code></pre>\n<p><code class=\"codespan\">value</code> is an object, containing the <code class=\"codespan\">min</code> value and <code class=\"codespan\">max</code> value of the data. This function should return the min value of axis, or return <code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> to make echarts use the auto calculated min value (<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> return is only supported since <code class=\"codespan\">v4.8.0</code>).</p>\n","uiControl":{"type":"number"},"default":null},"max":{"type":["number","string","Function"],"description":"\n\n<p>The maximum value of axis.</p>\n<p>It can be set to a special value <code class=\"codespan\">&#39;dataMax&#39;</code> so that the minimum value on this axis is set to be the maximum label.</p>\n<p>It will be automatically computed to make sure axis tick is equally distributed when not set.</p>\n<p>In category axis, it can also be set as the ordinal number. For example, if a catergory axis has <code class=\"codespan\">data: [&#39;categoryA&#39;, &#39;categoryB&#39;, &#39;categoryC&#39;]</code>, and the ordinal <code class=\"codespan\">2</code> represents <code class=\"codespan\">&#39;categoryC&#39;</code>. Moreover, it can be set as negative number, like <code class=\"codespan\">-3</code>.</p>\n<p>If <code class=\"codespan\">max</code> is specified as a function, it should return a max value, like:</p>\n<pre><code class=\"lang-js\">max: function (value) {\n    return value.max - 20;\n}\n</code></pre>\n<p><code class=\"codespan\">value</code> is an object, containing the <code class=\"codespan\">min</code> value and <code class=\"codespan\">max</code> value of the data. This function should return the max value of axis, or return <code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> to make echarts use the auto calculated max value (<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> return is only supported since <code class=\"codespan\">v4.8.0</code>).</p>\n","uiControl":{"type":"number"},"default":null},"scale":{"type":["boolean"],"description":"\n\n<p>It is available only in numerical axis, i.e., <a href=\"#angleAxis.type\">type</a>: &#39;value&#39;.</p>\n<p>It specifies whether not to contain zero position of axis compulsively. When it is set to be <code class=\"codespan\">true</code>, the axis may not contain zero position, which is useful in the scatter chart for both value axes.</p>\n<p>This configuration item is unavailable when the <a href=\"#angleAxis.min\">min</a> and <a href=\"#angleAxis.max\">max</a> are set.</p>\n","uiControl":{"type":"boolean"},"default":false},"splitNumber":{"type":["number"],"description":"\n\n<p>Number of segments that the axis is split into. Note that this number serves only as a recommendation, and the true segments may be adjusted based on readability.</p>\n<p>This is unavailable for category axis.</p>\n","uiControl":{"type":"number","min":"1","step":"1","default":"5"},"default":5},"minInterval":{"type":["number"],"description":"\n\n<p>Minimum gap between split lines.</p>\n<p>For example, it can be set to be <code class=\"codespan\">1</code> to make sure axis label is show as integer.</p>\n<pre><code class=\"lang-js\">{\n    minInterval: 1\n}\n</code></pre>\n<p>It is available only for axis of <a href=\"#angleAxis.type\">type</a> &#39;value&#39; or &#39;time&#39;.</p>\n","uiControl":{"type":"number"},"default":0},"maxInterval":{"type":["number"],"description":"\n\n<p>Maximum gap between split lines.</p>\n<p>For example, in time axis (<a href=\"#angleAxis.type\">type</a> is &#39;time&#39;), it can be set to be <code class=\"codespan\">3600 * 24 * 1000</code> to make sure that the gap between axis labels is less than or equal to one day.</p>\n<pre><code class=\"lang-js\">{\n    maxInterval: 3600 * 1000 * 24\n}\n</code></pre>\n<p>It is available only for axis of <a href=\"#angleAxis.type\">type</a> &#39;value&#39; or &#39;time&#39;.</p>\n","uiControl":{"type":"number"}},"interval":{"type":["number"],"description":"\n\n<p>Compulsively set segmentation interval for axis.</p>\n<p>As <a href=\"#angleAxis.splitNumber\">splitNumber</a> is a recommendation value, the calculated tick may not be the same as expected. In this case, interval should be used along with <a href=\"#angleAxis.min\">min</a> and <a href=\"#angleAxis.max\">max</a> to compulsively set tickings. But in most cases, we do not suggest using this, out automatic calculation is enough for most situations.</p>\n<p>This is unavailable for category axis. Timestamp should be passed for <a href=\"#angleAxis.type\">type</a>: &#39;time&#39; axis. Logged value should be passed for <a href=\"#angleAxis.type\">type</a>: &#39;log&#39; axis.</p>\n","uiControl":{"type":"number"}},"logBase":{"type":["number"],"description":"\n\n<p>Base of logarithm, which is valid only for numeric axes with <a href=\"#angleAxis.type\">type</a>: &#39;log&#39;.</p>\n","uiControl":{"type":"number","default":"10"},"default":10},"silent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code>, to prevent interaction with the axis.</p>\n","default":false},"triggerEvent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code> to enable triggering events.</p>\n<p>Parameters of the event include:</p>\n<pre><code class=\"lang-js\">{\n    // Component type: xAxis, yAxis, radiusAxis, angleAxis\n    // Each of which has an attribute for index, e.g., xAxisIndex for xAxis\n    componentType: string,\n    // Value on axis before being formatted.\n    // Click on value label to trigger event.\n    value: &#39;&#39;,\n    // Name of axis.\n    // Click on laben name to trigger event.\n    name: &#39;&#39;\n}\n</code></pre>\n","default":false},"axisLine":{"type":["Object"],"description":"<p>Settings related to axis line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis line from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"symbol":{"type":["string","Array"],"description":"\n\n<p>Symbol of the two ends of the axis. It could be a string, representing the same symbol for two ends; or an array with two string elements, representing the two ends separately. It&#39;s set to be <code class=\"codespan\">&#39;none&#39;</code> by default, meaning no arrow for either end. If it is set to be <code class=\"codespan\">&#39;arrow&#39;</code>, there shall be two arrows. If there should only one arrow at the end, it should set to be <code class=\"codespan\">[&#39;none&#39;, &#39;arrow&#39;]</code>.</p>\n","uiControl":{"type":"icon","default":"none"},"default":"'none'"},"symbolSize":{"type":["Array"],"description":"\n\n<p>Size of the arrows at two ends. The first is the width perpendicular to the axis, the next is the width parallel to the axis.</p>\n","uiControl":{"type":"vector","default":"10,15"},"default":"[10, 15]"},"symbolOffset":{"type":["Array","number"],"description":"\n\n<p>Arrow offset of axis. If is array, the first number is the offset of the arrow at the beginning, and the second number is the offset of the arrow at the end. If is number, it means the arrows have the same offset.</p>\n","uiControl":{"type":"vector","default":"0,0"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>line styleLine color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#333'"},"width":{"type":["number"],"description":"\n\n<p>line style line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>line style line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisTick":{"type":["Object"],"description":"<p>Settings related to axis tick.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis tick from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"alignWithLabel":{"type":["boolean"],"description":"\n\n<p>Align axis tick with label, which is available only when <code class=\"codespan\">boundaryGap</code> is set to be <code class=\"codespan\">true</code> in category axis. See the following picture:</p>\n<p><img width=\"600\" height=\"auto\" src=\"documents/asset/img/axis-align-with-label.png\"></p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of axisTick, which is available in category axis.  is set to be the same as <a href=\"#angleAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"inside":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> so the axis labels face the <code class=\"codespan\">inside</code> direction.</p>\n","uiControl":{"type":"boolean"},"default":false},"length":{"type":["number"],"description":"\n\n<p>The length of the axis tick.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"5"},"default":5},"lineStyle":{"type":["Object"],"description":"<p>Line style of axis ticks.</p>\n","properties":{"color":{"type":["Color"],"description":"<p>Color of axis label is set to be <a href=\"#angleAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default.</p>\n"},"width":{"type":["number"],"description":"\n\n<p>axisTick line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>axisTick line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"minorTick":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.6.0</code></p>\n</blockquote>\n<p>Settings related minor ticks.</p>\n<p>Note: <code class=\"codespan\">minorTick</code> is not available in the <code class=\"codespan\">category</code> type axis.</p>\n<p>Examples:</p>\n<p>1) Using minor ticks in function plotting.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-function&edit=1&reset=1\" width=\"600\" height=\"350\"></iframe>\n\n\n<p>2) Using minor ticks in log axis.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-log&edit=1&reset=1\" width=\"600\" height=\"350\"></iframe>\n\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>If show minor ticks.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"splitNumber":{"type":["number"],"description":"\n\n<p>Number of interval splited by minor ticks.</p>\n","uiControl":{"type":"number","min":"1","step":"1","default":"5"},"default":5},"length":{"type":["number"],"description":"\n\n<p>Length of minor ticks lines。</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"3"},"default":3},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Style configuration of minor ticks lines <a href=\"#angleAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a>。</p>\n","uiControl":{"type":"color"}},"width":{"type":["number"],"description":"\n\n<p>minorTick line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>minorTick line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisLabel":{"type":["Object"],"description":"<p>Settings related to axis label.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis label from appearing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis label, which is available in category axis. </p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"inside":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> so the axis labels face the <code class=\"codespan\">inside</code> direction.</p>\n","uiControl":{"type":"boolean"},"default":false},"margin":{"type":["number"],"description":"\n\n<p>The margin between the axis label and the axis line.</p>\n","uiControl":{"type":"number","default":"8","step":"0.5"},"default":8},"formatter":{"type":["string","Function"],"description":"<p>Formatter of axis label, which supports string template and callback function.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use string template; template variable is the default label of axis {value}\nformatter: &#39;{value} kg&#39;\n// Use callback.\nformatter: function (value, index) {\n    return value + &#39;kg&#39;;\n}\n</code></pre>\n<hr>\n<p>For axes of time <a href=\"#.type\">type</a>: <code class=\"codespan\">&#39;time&#39;</code>, <code class=\"codespan\">formatter</code> supports the following forms:</p>\n<ul>\n<li><strong>String Templates</strong>: an easy and fast way to make frequently used date/time template, formed in <code class=\"codespan\">string</code></li>\n<li><strong>Callback Functions</strong>: customized formatter to make complex format, formed in <code class=\"codespan\">Function</code></li>\n<li><strong>Cascading Templates</strong>: to adopt different formatters for different time granularity, formed in <code class=\"codespan\">object</code></li>\n</ul>\n<p>Next, we are going to introduce these three forms one by one.</p>\n<p><strong> String Templates </strong></p>\n<p>Using string templates is an easy way to format date/time with frequently used formats. If it can be used to make what you want, you are advised to do so. If not, you could then consider the others. Supported formats are:</p>\n<table>\n<thead>\n<tr>\n<th>Group</th>\n<th>Template</th>\n<th>Value (EN)</th>\n<th>Value (ZH)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Year</td>\n<td>{yyyy}</td>\n<td>e.g., 2020, 2021, ...</td>\n<td>例：2020, 2021, ...</td>\n</tr>\n<tr>\n<td></td>\n<td>{yy}</td>\n<td>00-99</td>\n<td>00-99</td>\n</tr>\n<tr>\n<td>Quarter</td>\n<td>{Q}</td>\n<td>1, 2, 3, 4</td>\n<td>1, 2, 3, 4</td>\n</tr>\n<tr>\n<td>Month</td>\n<td>{MMMM}</td>\n<td>e.g., January, February, ...</td>\n<td>一月、二月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MMM}</td>\n<td>e.g., Jan, Feb, ...</td>\n<td>1月、2月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MM}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{M}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Day of Month</td>\n<td>{dd}</td>\n<td>01-31</td>\n<td>01-31</td>\n</tr>\n<tr>\n<td></td>\n<td>{d}</td>\n<td>1-31</td>\n<td>1-31</td>\n</tr>\n<tr>\n<td>Day of Week</td>\n<td>{eeee}</td>\n<td>Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday</td>\n<td>星期日、星期一、星期二、星期三、星期四、星期五、星期六</td>\n</tr>\n<tr>\n<td></td>\n<td>{ee}</td>\n<td>Sun, Mon, Tues, Wed, Thu, Fri, Sat</td>\n<td>日、一、二、三、四、五、六</td>\n</tr>\n<tr>\n<td></td>\n<td>{e}</td>\n<td>1-54</td>\n<td>1-54</td>\n</tr>\n<tr>\n<td>Hour</td>\n<td>{HH}</td>\n<td>00-23</td>\n<td>00-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{H}</td>\n<td>0-23</td>\n<td>0-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{hh}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{h}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Minute</td>\n<td>{mm}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{m}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Second</td>\n<td>{ss}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{s}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Millisecond</td>\n<td>{SSS}</td>\n<td>000-999</td>\n<td>000-999</td>\n</tr>\n<tr>\n<td></td>\n<td>{S}</td>\n<td>0-999</td>\n<td>0-999</td>\n</tr>\n</tbody>\n</table>\n<blockquote>\n<p>Templates of other languages can be found in <a href=\"https://github.com/apache/echarts/tree/master/src/i18n\" target=\"_blank\">the language package</a>. Please refer to <a href=\"api.html#echarts.registerLocale\" target=\"_blank\">echarts.registerLocale</a> to register a language.</p>\n</blockquote>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: &#39;{yyyy}-{MM}-{dd}&#39; // gets labels like &#39;2020-12-02&#39;\nformatter: &#39;Day {d}&#39; // gets labels like &#39;Day 2&#39;\n</code></pre>\n<p><strong> Callback Functions </strong></p>\n<p>Callback functions can be used to get different formats for different axis tick values. Sometimes, if you have complex date/time formatting requirement, third-party libraries like <a href=\"https://momentjs.com/\" target=\"_blank\">Moment.js</a> or <a href=\"https://date-fns.org/\" target=\"_blank\">date-fns</a> can be used to return formatted labels.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use callback function; function parameters are axis index\nformatter: function (value, index) {\n    // Formatted to be month/day; display year only in the first label\n    var date = new Date(value);\n    var texts = [(date.getMonth() + 1), date.getDate()];\n    if (idx === 0) {\n        texts.unshift(date.getYear());\n    }\n    return texts.join(&#39;/&#39;);\n}\n</code></pre>\n<p><strong> Cascading Templates </strong></p>\n<p>Sometimes, we wish to use different formats for different time granularity. For example, in a quarter-year chart, we may wish to see the month name with the first date of the month, while see the date name with others. This can be made with:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: {\n    month: &#39;{MMMM}&#39;, // Jan, Feb, ...\n    day: &#39;{d}&#39; // 1, 2, ...\n}\n</code></pre>\n<p>Supported levels and their default formatters are:</p>\n<pre><code class=\"lang-js\">{\n    year: &#39;{yyyy}&#39;,\n    month: &#39;{MMM}&#39;,\n    day: &#39;{d}&#39;,\n    hour: &#39;{HH}:{mm}&#39;,\n    minute: &#39;{HH}:{mm}&#39;,\n    second: &#39;{HH}:{mm}:{ss}&#39;,\n    millisecond: &#39;{hh}:{mm}:{ss} {SSS}&#39;,\n    none: &#39;{yyyy}-{MM}-{dd} {hh}:{mm}:{ss} {SSS}&#39;\n}\n</code></pre>\n<p>Let&#39;s take <code class=\"codespan\">day</code> for example. When a tick value is <code class=\"codespan\">0</code> for its hour, minute, second, and millisecond, <code class=\"codespan\">day</code> level will be used to make formatter. <code class=\"codespan\">none</code> is used when no other level fulfills, which is for tick values with millisecond values other than <code class=\"codespan\">0</code>.</p>\n<p><strong> Rich Text </strong></p>\n<p>The above three forms all support rich text, so it can be used to make some complex effects.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: {\n            // Display year and month information on the first data of a year\n            year: &#39;{yearStyle|{yyyy}}\\n{monthStyle|{MMM}}&#39;,\n            month: &#39;{monthStyle|{MMM}}&#39;\n        },\n        rich: {\n            yearStyle: {\n                // Make yearly text more standing out\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            monthStyle: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n<p>The above example can also be made with a callback function:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: function (value) {\n            const date = new Date(value);\n            const yearStart = new Date(value);\n            yearStart.setMonth(0);\n            yearStart.setDate(1);\n            yearStart.setHours(0);\n            yearStart.setMinutes(0);\n            yearStart.setSeconds(0);\n            yearStart.setMilliseconds(0);\n            // Whether a tick value is the start of a year\n            if (date.getTime() === yearStart.getTime()) {\n                return &#39;{year|&#39; + date.getFullYear() + &#39;}\\n&#39;\n                    + &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;;\n            }\n            else {\n                return &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;\n            }\n        },\n        rich: {\n            year: {\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            month: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n","default":null},"showMinLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the min tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the min tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"showMaxLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the max tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the max tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"color":{"type":["Color","Function"],"description":"\n\n<p>Color of axis label is set to be <a href=\"#angleAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default. Callback function is supported, in the following format:</p>\n<pre><code class=\"lang-js\">(val: string) =&gt; Color\n</code></pre>\n<p>Parameter is the text of label, and return value is the color. See the following example:</p>\n<pre><code class=\"lang-js\">textStyle: {\n    color: function (value, index) {\n        return value &gt;= 0 ? &#39;green&#39; : &#39;red&#39;;\n    }\n}\n</code></pre>\n","uiControl":{"type":"color"}},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"splitLine":{"type":["Object"],"description":"<p>Split line of axis in <a href=\"#grid\">grid</a> area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the splitLine from showing.\n<code class=\"codespan\">value</code> type axes are shown by default, while <code class=\"codespan\">category</code> type axes are hidden.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis splitLine, which is available in category axis.  is set to be the same as <a href=\"#angleAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Array","string"],"description":"\n\n<p>The color of the splitLine, which could be set separately.</p>\n<p>SplitLine color could also be set in color array, which the split lines would take as their colors in turns.</p>\n<p>Example:</p>\n<pre><code>splitLine: {\n    lineStyle: {\n        // Dark and light colors will be used in turns\n        color: [&#39;#aaa&#39;, &#39;#ddd&#39;]\n    }\n}\n</code></pre>","uiControl":{"type":"color"},"default":"['#ccc']"},"width":{"type":["number"],"description":"\n\n<p>splitLine line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>splitLine line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"minorSplitLine":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.6.0</code></p>\n</blockquote>\n<p>Minor split lines of axis in the <a href=\"#grid\">grid</a> area。It will align to the <a href=\"#angleAxis.minorTick\">minorTick</a></p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>If show minor split lines.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>minorSplitLineLine color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#eee'"},"width":{"type":["number"],"description":"\n\n<p>minorSplitLine line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>minorSplitLine line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"splitArea":{"type":["Object"],"description":"<p>Split area of axis in <a href=\"#grid\">grid</a> area, not shown by default.</p>\n","properties":{"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis splitArea, which is available in category axis.  is set to be the same as <a href=\"#angleAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> to show the splitArea.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"areaStyle":{"type":["Object"],"description":"<p>Split area style.</p>\n","properties":{"color":{"type":["Array"],"description":"<p>Color of split area.\nSplitArea color could also be set in color array, which the split lines would take as their colors in turns. Dark and light colors in turns are used by default.</p>\n","default":"['rgba(250,250,250,0.3)','rgba(200,200,200,0.3)']"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Category data, available in <a href=\"#angleAxis.type\">type</a>: &#39;category&#39; axis.</p>\n<p>If <a href=\"#angleAxis.type\">type</a> is not specified, but <code class=\"codespan\">axis.data</code> is specified, the <a href=\"#angleAxis.type\">type</a> is auto set as <code class=\"codespan\">&#39;category&#39;</code>.</p>\n<p>If <a href=\"#angleAxis.type\">type</a> is specified as <code class=\"codespan\">&#39;category&#39;</code>, but <code class=\"codespan\">axis.data</code> is not specified, <code class=\"codespan\">axis.data</code> will be auto collected from <a href=\"#series.data\">series.data</a>. It brings convenience, but we should notice that <code class=\"codespan\">axis.data</code> provides then value range of the <code class=\"codespan\">&#39;category&#39;</code> axis. If  it is auto collected from <a href=\"#series.data\">series.data</a>, Only the values appearing in <a href=\"#series.data\">series.data</a> can be collected. For example, if <a href=\"#series.data\">series.data</a> is empty, nothing will be collected.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Name list of all categories\ndata: [&#39;Monday&#39;, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;, &#39;Friday&#39;, &#39;Saturday&#39;, &#39;Sunday&#39;]\n// Each item could also be a specific configuration item.\n// In this case, `value` is used as the category name.\ndata: [{\n    value: &#39;Monday&#39;,\n    // Highlight Monday\n    textStyle: {\n        fontSize: 20,\n        color: &#39;red&#39;\n    }\n}, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;, &#39;Friday&#39;, &#39;Saturday&#39;, &#39;Sunday&#39;]\n</code></pre>\n","items":{"type":"Object","properties":{"value":{"type":["string"],"description":"<p>Name of a category.</p>\n"},"textStyle":{"type":["Object"],"description":"<p>Text style of the category.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}},"axisPointer":{"type":["Object"],"description":"<p>axisPointer settings on the axis.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>axisPointer will not be displayed by default. But if <a href=\"#tooltip.trigger\">tooltip.trigger</a> is set as <code class=\"codespan\">&#39;axis&#39;</code> or <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, axisPointer will be displayed automatically. Each coordinate system will automatically chose the axes whose will display its axisPointer. <a href=\"#tooltip.axisPointer.axis\">tooltip.axisPointer.axis</a> can be used to change the choice.</p>\n","uiControl":{"type":"boolean"},"default":false},"type":{"type":["string"],"description":"\n\n<p>Indicator type.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;line&#39;</code> line indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;shadow&#39;</code> shadow crosshair indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code> no indicator displayed.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"line,shadow,none"},"default":"'line'"},"snap":{"type":["boolean"],"description":"<p>Whether snap to point automatically. The default value is auto determined.</p>\n<p>This feature usually makes sense in value axis and time axis, where tiny points can be seeked automatically.</p>\n"},"z":{"type":["number"],"description":"<p>z value, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n"},"label":{"type":["Object"],"description":"<p>label of axisPointer</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label. Label will not show by default. But if <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, label will be displayed automatically.</p>\n","default":false},"precision":{"type":["number","string"],"description":"<p>The precision of value in label. It is auto determined by default. You can also set it as <code class=\"codespan\">&#39;2&#39;</code>, which indicates that two decimal fractions are reserved.</p>\n","default":"'auto'"},"formatter":{"type":["string","Function"],"description":"<p>The formatter of label.</p>\n<p>If set as <code class=\"codespan\">string</code>, for example it can be: <code class=\"codespan\">formatter: &#39;some text {value} some text</code>, where <code class=\"codespan\">{value}</code> will be replaced by axis value automatically.</p>\n<p>If set as <code class=\"codespan\">function</code>:</p>\n<p><strong>Parameters:</strong></p>\n<p><code class=\"codespan\">{Object}</code> params: Including fields as follows:</p>\n<p><code class=\"codespan\">{Object}</code> params.value: current value of this axis. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;category&#39;</code>, it is one of the value in <code class=\"codespan\">axis.data</code>. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;time&#39;</code>, it is a timestamp.</p>\n<p><code class=\"codespan\">{Array.&lt;Object&gt;}</code> params.seriesData: An array, containing info of nearest points. Each item is:</p>\n<p><code class=\"codespan\">{string}</code> params.axisDimension: The dimension name of the axis. For example, in catesian it will be <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, and in polar it will be <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code>.</p>\n<p><code class=\"codespan\">{number}</code> params.axisIndex: The index of the axis, for example, <code class=\"codespan\">0</code>,<code class=\"codespan\">1</code>, <code class=\"codespan\">2</code>, ...</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>Each item also includes axis infomation:</p>\n<pre><code class=\"lang-js\">{\n    axisDim: &#39;x&#39;, // &#39;x&#39;, &#39;y&#39;, &#39;angle&#39;, &#39;radius&#39;, &#39;single&#39;\n    axisId: &#39;xxx&#39;,\n    axisName: &#39;xxx&#39;,\n    axisIndex: 3,\n    axisValue: 121, // The current value of axisPointer\n    axisValueLabel: &#39;text of value&#39;\n}\n</code></pre>\n<p><strong>Return:</strong></p>\n<p>The string to be displayed.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">formatter: function (params) {\n    // If axis.type is &#39;time&#39;\n    return &#39;some text&#39; + echarts.format.formatTime(params.value);\n}\n</code></pre>\n","default":null},"margin":{"type":["boolean"],"description":"<p>Distance between label and axis.</p>\n","default":3},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"padding":{"type":["string","Array"],"description":"\n\n<p>axisPointer space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":"[5, 7, 5, 7]"},"backgroundColor":{"type":["string"],"description":"<p>Background color of label, the same as <a href=\"#xAxis.axisLine.lineStyle.color\">axis.axisLine.lineStyle.color</a> by default.</p>\n","default":"'auto'"},"borderColor":{"type":["string"],"description":"<p>Border color of label.</p>\n","default":null},"borderWidth":{"type":["string"],"description":"<p>Border width of label.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"lineStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;line&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#555"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"shadowStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;shadow&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'rgba(150,150,150,0.3)"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"triggerTooltip":{"type":["boolean"],"description":"\n\n<p>Whether to trigger tooltip.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"value":{"type":["number"],"description":"<p>current value. When using <a href=\"xAxisPointer.handle\" target=\"_blank\">axisPointer.handle</a>, <code class=\"codespan\">value</code> can be set to define the initail position of axisPointer.</p>\n","default":null},"status":{"type":["boolean"],"description":"\n\n<p>Current status, can be <code class=\"codespan\">&#39;show&#39;</code> 和 <code class=\"codespan\">&#39;hide&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"show,hide"}},"handle":{"type":["Object"],"description":"<p>A button used to drag axisPointer. This feature is applicable in touch device. See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-tooltip-touch&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set to <code class=\"codespan\">true</code> to use handle.</p>\n","uiControl":{"type":"boolean"},"default":false},"icon":{"type":["*"],"description":"\n\n<p>The icon of the handle.</p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/axisPointer-handle-image&amp;edit=1&amp;reset=1\" target=\"_blank\">example of using image</a></p>\n","uiControl":{"type":"icon","clean":"true"}},"size":{"type":["number","Array"],"description":"\n\n<p>The size of the handle, which can be set as a single value or an array (<code class=\"codespan\">[width, height]</code>).</p>\n","uiControl":{"type":"vector","default":"45,45","min":"0","step":"0.5","dims":"width,height"},"default":45},"margin":{"type":["number"],"description":"\n\n<p>Distance from handle center to axis.</p>\n","uiControl":{"type":"number","default":"50","min":"0","step":"0.5"},"default":50},"color":{"type":["string"],"description":"\n\n<p>The color of the handle.</p>\n","uiControl":{"type":"color"},"default":"'#333'"},"throttle":{"type":["number"],"description":"\n\n<p>Throttle rate of trigger view update when dragging handle, in ms. Increase the value to improve performance, but decrease the experience.</p>\n","uiControl":{"type":"number","default":"40","min":"0","step":"10"},"default":40},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"2","step":"0.5"},"default":2},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in Angle Axis.</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in Angle Axis, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":0}}},"radar":{"type":["Object"],"description":"<p>Coordinate for <a href=\"#series-radar\">radar charts</a>. This component is equal to the polar component in ECharts 2. Because the polar component in the echarts 3 is reconstructed to be the standard polar coordinate component, this component is renamed to be radar to avoid confusion.</p>\n<p>Radar chart coordinate is different from polar coordinate, in that every axis indicator of the radar chart coordinate is an individual dimension. The style of indicator coordinate axis could be configured through the following configuration items, including <a href=\"#radar.name\">name</a>, <a href=\"#radar.axisLine\">axisLine</a>, <a href=\"#radar.axisTick\">axisTick</a>, <a href=\"#radar.axisLabel\">axisLabel</a>, <a href=\"#radar.splitLine\">splitLine</a>, <a href=\"#radar.splitArea\">splitArea</a>.</p>\n<p>Here is a custom example of radar component.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/radar&edit=1&reset=1\" width=\"400\" height=\"400\"></iframe>\n\n\n\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"center":{"type":["Array"],"description":"\n\n<p>Center position of , the first of which is the horizontal position, and the second is the vertical position.</p>\n<p>Percentage is supported. When set in percentage, the item is relative to the container width, and the second item to the height.</p>\n<p><strong>Example: </strong></p>\n<pre><code>// Set to absolute pixel values\ncenter: [400, 300]\n// Set to relative percent\ncenter: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>","uiControl":{"type":"percentvector","dims":"x,y"},"default":"['50%', '50%']"},"radius":{"type":["number","string","Array"],"description":"\n\n<p>Radius of . Value can be:</p>\n<ul>\n<li><code class=\"codespan\">number</code>: Specify outside radius directly.</li>\n<li><code class=\"codespan\">string</code>: For example, <code class=\"codespan\">&#39;20%&#39;</code>, means that the outside radius is 20% of the viewport size (the little one between width and height of the chart container).</li>\n</ul>\n<ul>\n<li><code class=\"codespan\">Array.&lt;number|string&gt;</code>: The first item specifies the inside radius, and the second item specifies the outside radius. Each item follows the definitions above.</li>\n</ul>\n","uiControl":{"type":"percentvector","dims":"inner,outer","default":"0%, 75%"},"default":"75%"},"startAngle":{"type":["number"],"description":"<p>The start angle of coordinate, which is the angle of the first indicator axis.</p>\n","default":90},"name":{"type":["Object"],"description":"<p>Name of radar chart.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether to display the indicator&#39;s name.</p>\n","default":true},"formatter":{"type":["string","Function"],"description":"<p>The formatter of indicator&#39;s name, in which the string and callback function are supported. See the following example:</p>\n<pre><code class=\"lang-js\">// using string template, the template variable should be the indicator&#39;s name {value}\nformatter: &#39;【{value}】&#39;\n// using callback function, the first parameter is the indicator&#39;s name, and the second parameter id the indicator&#39;s cinfiguration item\nformatter: function (value, indicator) {\n    return &#39;【&#39; + value + &#39;】&#39;;\n}\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#333'"},"default":"'#333'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"nameGap":{"type":["number"],"description":"\n\n<p>Distance between the indicator&#39;s name and axis.</p>\n","uiControl":{"type":"number","default":"15","step":"1"},"default":15},"splitNumber":{"type":["number"],"description":"\n\n<p>Segments of indicator axis.</p>\n","uiControl":{"type":"number","default":"15","step":"1"},"default":5},"shape":{"type":["string"],"description":"\n\n<p>Radar render type, in which <code class=\"codespan\">&#39;polygon&#39;</code> and <code class=\"codespan\">&#39;circle&#39;</code> are supported.</p>\n","uiControl":{"type":"enum","options":"polygon,circle"},"default":"'polygon'"},"scale":{"type":["boolean"],"description":"\n\n<p>Whether to prevent calculating the scaling relative to zero. If it is set to be <code class=\"codespan\">true</code>, the coordinate tick would not compulsorily contain zero value, which is usually useful in scatter diagram of double numerical values axis.</p>\n","uiControl":{"type":"boolean"},"default":false},"silent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code>, to prevent interaction with the axis.</p>\n","default":false},"triggerEvent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code> to enable triggering events.</p>\n<p>Parameters of the event include:</p>\n<pre><code class=\"lang-js\">{\n    // Component type: xAxis, yAxis, radiusAxis, angleAxis\n    // Each of which has an attribute for index, e.g., xAxisIndex for xAxis\n    componentType: string,\n    // Value on axis before being formatted.\n    // Click on value label to trigger event.\n    value: &#39;&#39;,\n    // Name of axis.\n    // Click on laben name to trigger event.\n    name: &#39;&#39;\n}\n</code></pre>\n","default":false},"axisLine":{"type":["Object"],"description":"<p>Settings related to axis line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis line from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"symbol":{"type":["string","Array"],"description":"\n\n<p>Symbol of the two ends of the axis. It could be a string, representing the same symbol for two ends; or an array with two string elements, representing the two ends separately. It&#39;s set to be <code class=\"codespan\">&#39;none&#39;</code> by default, meaning no arrow for either end. If it is set to be <code class=\"codespan\">&#39;arrow&#39;</code>, there shall be two arrows. If there should only one arrow at the end, it should set to be <code class=\"codespan\">[&#39;none&#39;, &#39;arrow&#39;]</code>.</p>\n","uiControl":{"type":"icon","default":"none"},"default":"'none'"},"symbolSize":{"type":["Array"],"description":"\n\n<p>Size of the arrows at two ends. The first is the width perpendicular to the axis, the next is the width parallel to the axis.</p>\n","uiControl":{"type":"vector","default":"10,15"},"default":"[10, 15]"},"symbolOffset":{"type":["Array","number"],"description":"\n\n<p>Arrow offset of axis. If is array, the first number is the offset of the arrow at the beginning, and the second number is the offset of the arrow at the end. If is number, it means the arrows have the same offset.</p>\n","uiControl":{"type":"vector","default":"0,0"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>line styleLine color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#333'"},"width":{"type":["number"],"description":"\n\n<p>line style line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>line style line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisTick":{"type":["Object"],"description":"<p>Settings related to axis tick.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis tick from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"length":{"type":["number"],"description":"\n\n<p>The length of the axis tick.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"5"},"default":5},"lineStyle":{"type":["Object"],"description":"<p>Line style of axis ticks.</p>\n","properties":{"color":{"type":["Color"],"description":"<p>Color of axis label is set to be <a href=\"#.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default.</p>\n"},"width":{"type":["number"],"description":"\n\n<p>axisTick line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>axisTick line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisLabel":{"type":["Object"],"description":"<p>Settings related to axis label.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis label from appearing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"rotate":{"type":["number"],"description":"\n\n<p>Rotation degree of axis label, which is especially useful when there is no enough space for category axis.</p>\n<p>Rotation degree is from -90 to 90.</p>\n","uiControl":{"type":"angle","min":"-90","max":"90","step":"1"},"default":0},"margin":{"type":["number"],"description":"\n\n<p>The margin between the axis label and the axis line.</p>\n","uiControl":{"type":"number","default":"8","step":"0.5"},"default":8},"formatter":{"type":["string","Function"],"description":"<p>Formatter of axis label, which supports string template and callback function.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use string template; template variable is the default label of axis {value}\nformatter: &#39;{value} kg&#39;\n// Use callback.\nformatter: function (value, index) {\n    return value + &#39;kg&#39;;\n}\n</code></pre>\n<hr>\n<p>For axes of time <a href=\"#.type\">type</a>: <code class=\"codespan\">&#39;time&#39;</code>, <code class=\"codespan\">formatter</code> supports the following forms:</p>\n<ul>\n<li><strong>String Templates</strong>: an easy and fast way to make frequently used date/time template, formed in <code class=\"codespan\">string</code></li>\n<li><strong>Callback Functions</strong>: customized formatter to make complex format, formed in <code class=\"codespan\">Function</code></li>\n<li><strong>Cascading Templates</strong>: to adopt different formatters for different time granularity, formed in <code class=\"codespan\">object</code></li>\n</ul>\n<p>Next, we are going to introduce these three forms one by one.</p>\n<p><strong> String Templates </strong></p>\n<p>Using string templates is an easy way to format date/time with frequently used formats. If it can be used to make what you want, you are advised to do so. If not, you could then consider the others. Supported formats are:</p>\n<table>\n<thead>\n<tr>\n<th>Group</th>\n<th>Template</th>\n<th>Value (EN)</th>\n<th>Value (ZH)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Year</td>\n<td>{yyyy}</td>\n<td>e.g., 2020, 2021, ...</td>\n<td>例：2020, 2021, ...</td>\n</tr>\n<tr>\n<td></td>\n<td>{yy}</td>\n<td>00-99</td>\n<td>00-99</td>\n</tr>\n<tr>\n<td>Quarter</td>\n<td>{Q}</td>\n<td>1, 2, 3, 4</td>\n<td>1, 2, 3, 4</td>\n</tr>\n<tr>\n<td>Month</td>\n<td>{MMMM}</td>\n<td>e.g., January, February, ...</td>\n<td>一月、二月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MMM}</td>\n<td>e.g., Jan, Feb, ...</td>\n<td>1月、2月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MM}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{M}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Day of Month</td>\n<td>{dd}</td>\n<td>01-31</td>\n<td>01-31</td>\n</tr>\n<tr>\n<td></td>\n<td>{d}</td>\n<td>1-31</td>\n<td>1-31</td>\n</tr>\n<tr>\n<td>Day of Week</td>\n<td>{eeee}</td>\n<td>Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday</td>\n<td>星期日、星期一、星期二、星期三、星期四、星期五、星期六</td>\n</tr>\n<tr>\n<td></td>\n<td>{ee}</td>\n<td>Sun, Mon, Tues, Wed, Thu, Fri, Sat</td>\n<td>日、一、二、三、四、五、六</td>\n</tr>\n<tr>\n<td></td>\n<td>{e}</td>\n<td>1-54</td>\n<td>1-54</td>\n</tr>\n<tr>\n<td>Hour</td>\n<td>{HH}</td>\n<td>00-23</td>\n<td>00-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{H}</td>\n<td>0-23</td>\n<td>0-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{hh}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{h}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Minute</td>\n<td>{mm}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{m}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Second</td>\n<td>{ss}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{s}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Millisecond</td>\n<td>{SSS}</td>\n<td>000-999</td>\n<td>000-999</td>\n</tr>\n<tr>\n<td></td>\n<td>{S}</td>\n<td>0-999</td>\n<td>0-999</td>\n</tr>\n</tbody>\n</table>\n<blockquote>\n<p>Templates of other languages can be found in <a href=\"https://github.com/apache/echarts/tree/master/src/i18n\" target=\"_blank\">the language package</a>. Please refer to <a href=\"api.html#echarts.registerLocale\" target=\"_blank\">echarts.registerLocale</a> to register a language.</p>\n</blockquote>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: &#39;{yyyy}-{MM}-{dd}&#39; // gets labels like &#39;2020-12-02&#39;\nformatter: &#39;Day {d}&#39; // gets labels like &#39;Day 2&#39;\n</code></pre>\n<p><strong> Callback Functions </strong></p>\n<p>Callback functions can be used to get different formats for different axis tick values. Sometimes, if you have complex date/time formatting requirement, third-party libraries like <a href=\"https://momentjs.com/\" target=\"_blank\">Moment.js</a> or <a href=\"https://date-fns.org/\" target=\"_blank\">date-fns</a> can be used to return formatted labels.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use callback function; function parameters are axis index\nformatter: function (value, index) {\n    // Formatted to be month/day; display year only in the first label\n    var date = new Date(value);\n    var texts = [(date.getMonth() + 1), date.getDate()];\n    if (idx === 0) {\n        texts.unshift(date.getYear());\n    }\n    return texts.join(&#39;/&#39;);\n}\n</code></pre>\n<p><strong> Cascading Templates </strong></p>\n<p>Sometimes, we wish to use different formats for different time granularity. For example, in a quarter-year chart, we may wish to see the month name with the first date of the month, while see the date name with others. This can be made with:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: {\n    month: &#39;{MMMM}&#39;, // Jan, Feb, ...\n    day: &#39;{d}&#39; // 1, 2, ...\n}\n</code></pre>\n<p>Supported levels and their default formatters are:</p>\n<pre><code class=\"lang-js\">{\n    year: &#39;{yyyy}&#39;,\n    month: &#39;{MMM}&#39;,\n    day: &#39;{d}&#39;,\n    hour: &#39;{HH}:{mm}&#39;,\n    minute: &#39;{HH}:{mm}&#39;,\n    second: &#39;{HH}:{mm}:{ss}&#39;,\n    millisecond: &#39;{hh}:{mm}:{ss} {SSS}&#39;,\n    none: &#39;{yyyy}-{MM}-{dd} {hh}:{mm}:{ss} {SSS}&#39;\n}\n</code></pre>\n<p>Let&#39;s take <code class=\"codespan\">day</code> for example. When a tick value is <code class=\"codespan\">0</code> for its hour, minute, second, and millisecond, <code class=\"codespan\">day</code> level will be used to make formatter. <code class=\"codespan\">none</code> is used when no other level fulfills, which is for tick values with millisecond values other than <code class=\"codespan\">0</code>.</p>\n<p><strong> Rich Text </strong></p>\n<p>The above three forms all support rich text, so it can be used to make some complex effects.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: {\n            // Display year and month information on the first data of a year\n            year: &#39;{yearStyle|{yyyy}}\\n{monthStyle|{MMM}}&#39;,\n            month: &#39;{monthStyle|{MMM}}&#39;\n        },\n        rich: {\n            yearStyle: {\n                // Make yearly text more standing out\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            monthStyle: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n<p>The above example can also be made with a callback function:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: function (value) {\n            const date = new Date(value);\n            const yearStart = new Date(value);\n            yearStart.setMonth(0);\n            yearStart.setDate(1);\n            yearStart.setHours(0);\n            yearStart.setMinutes(0);\n            yearStart.setSeconds(0);\n            yearStart.setMilliseconds(0);\n            // Whether a tick value is the start of a year\n            if (date.getTime() === yearStart.getTime()) {\n                return &#39;{year|&#39; + date.getFullYear() + &#39;}\\n&#39;\n                    + &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;;\n            }\n            else {\n                return &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;\n            }\n        },\n        rich: {\n            year: {\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            month: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n","default":null},"showMinLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the min tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the min tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"showMaxLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the max tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the max tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"color":{"type":["Color","Function"],"description":"\n\n<p>Color of axis label is set to be <a href=\"#.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default. Callback function is supported, in the following format:</p>\n<pre><code class=\"lang-js\">(val: string) =&gt; Color\n</code></pre>\n<p>Parameter is the text of label, and return value is the color. See the following example:</p>\n<pre><code class=\"lang-js\">textStyle: {\n    color: function (value, index) {\n        return value &gt;= 0 ? &#39;green&#39; : &#39;red&#39;;\n    }\n}\n</code></pre>\n","uiControl":{"type":"color"}},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"splitLine":{"type":["Object"],"description":"<p>Split line of axis in <a href=\"#grid\">grid</a> area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the splitLine from showing.\n<code class=\"codespan\">value</code> type axes are shown by default, while <code class=\"codespan\">category</code> type axes are hidden.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Array","string"],"description":"\n\n<p>The color of the splitLine, which could be set separately.</p>\n<p>SplitLine color could also be set in color array, which the split lines would take as their colors in turns.</p>\n<p>Example:</p>\n<pre><code>splitLine: {\n    lineStyle: {\n        // Dark and light colors will be used in turns\n        color: [&#39;#aaa&#39;, &#39;#ddd&#39;]\n    }\n}\n</code></pre>","uiControl":{"type":"color"},"default":"['#ccc']"},"width":{"type":["number"],"description":"\n\n<p>splitLine line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>splitLine line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"splitArea":{"type":["Object"],"description":"<p>Split area of axis in <a href=\"#grid\">grid</a> area, not shown by default.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> to show the splitArea.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"areaStyle":{"type":["Object"],"description":"<p>Split area style.</p>\n","properties":{"color":{"type":["Array"],"description":"<p>Color of split area.\nSplitArea color could also be set in color array, which the split lines would take as their colors in turns. Dark and light colors in turns are used by default.</p>\n","default":"['rgba(250,250,250,0.3)','rgba(200,200,200,0.3)']"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"indicator":{"type":["Array"],"description":"<p>Indicator of radar chart, which is used to assign multiple variables(dimensions) in radar chart. Here is the example.</p>\n<pre><code class=\"lang-js\">indicator: [\n   { name: &#39;Sales (sales) &#39;, max: 6500},\n   { name: &#39;Administration (Administration) &#39;, max: 16000, color: &#39;red&#39;}, // Set the indicator as &#39;red&#39;\n   { name: &#39;Information Technology (Information Technology) &#39;, max: 30000},\n   { name: &#39;Customer Support (Customer Support) &#39;, max: 38000},\n   { name: &#39;Development (Development) &#39;, max: 52000},\n   { name: &#39;Marketing (Marketing) &#39;, max: 25000}\n]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Indicator&#39;s name.</p>\n"},"max":{"type":["number"],"description":"\n\n<p>The maximum value of indicator. It is an optional configuration, but we recommend to set it manually.</p>\n","uiControl":{"type":"number","default":"100","step":"1"}},"min":{"type":["number"],"description":"\n\n<p>The minimum value of indicator. It it an optional configuration, with default value of 0.</p>\n","uiControl":{"type":"number","step":"1"}},"color":{"type":["string"],"description":"\n\n<p>Specfy a color of the indicator.</p>\n","uiControl":{"type":"color"}}}}}}},"dataZoom":{"type":"Array","items":{"anyOf":[{"type":["Object"],"description":"<p><strong>dataZoomInside</strong></p>\n<p>Data zoom component of <em>inside</em> type.</p>\n<p>Refer to <a href=\"#dataZoom\">dataZoom</a> for more information.</p>\n<p>The <em>inside</em> means it&#39;s inside the coordinates.</p>\n<ul>\n<li>Translation: data area can be translated when moving in coordinates.</li>\n<li>Scaling:<ul>\n<li>PC: when mouse rolls (similar with touch pad) in coordinates.</li>\n<li>Mobile: when touches and moved with two fingers in coordinates on touch screens.</li>\n</ul>\n</li>\n</ul>\n<p><br>\n<br></p>\n","properties":{"type":{"type":["string"],"description":"","default":"'inside'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"disabled":{"type":["boolean"],"description":"\n\n<p>Whether disable inside zoom.</p>\n","uiControl":{"type":"boolean"},"default":false},"xAxisIndex":{"type":["number","Array"],"description":"<p>Specify which <a href=\"#xAxis\">xAxis</a> is/are controlled by the <code class=\"codespan\">dataZoom-inside</code> when <a href=\"#grid\">catesian coordinate system</a> is used.</p>\n<p>By default the first <code class=\"codespan\">xAxis</code> that parallel to <code class=\"codespan\">dataZoom</code> are controlled when <a href=\"#dataZoom-inside.orient\">dataZoom-inside.orient</a> is set as <code class=\"codespan\">&#39;horizontal&#39;</code>. But it is recommended to specify it explicitly but not use default value.</p>\n<p>If it is set as a single <code class=\"codespan\">number</code>, one axis is controlled, while if it is set as an <code class=\"codespan\">Array</code> , multiple axes are controlled.</p>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">option: {\n    xAxis: [\n        {...}, // The first xAxis\n        {...}, // The second xAxis\n        {...}, // The third xAxis\n        {...}  // The fourth xAxis\n    ],\n    dataZoom: [\n        { // The first dataZoom component\n            xAxisIndex: [0, 2] // Indicates that this dataZoom component\n                                     // controls the first and the third xAxis\n        },\n        { // The second dataZoom component\n            xAxisIndex: 3      // indicates that this dataZoom component\n                                     // controls the fourth xAxis\n        }\n    ]\n}\n</code></pre>\n","default":null},"yAxisIndex":{"type":["number","Array"],"description":"<p>Specify which <a href=\"#yAxis\">yAxis</a> is/are controlled by the <code class=\"codespan\">dataZoom-inside</code> when <a href=\"#grid\">catesian coordinate system</a> is used.</p>\n<p>By default the first <code class=\"codespan\">yAxis</code> that parallel to <code class=\"codespan\">dataZoom</code> are controlled when <a href=\"#dataZoom-inside.orient\">dataZoom-inside.orient</a> is set as <code class=\"codespan\">&#39;vertical&#39;</code>. But it is recommended to specify it explicitly but not use default value.</p>\n<p>If it is set as a single <code class=\"codespan\">number</code>, one axis is controlled, while if it is set as an <code class=\"codespan\">Array</code> , multiple axes are controlled.</p>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">option: {\n    yAxis: [\n        {...}, // The first yAxis\n        {...}, // The second yAxis\n        {...}, // The third yAxis\n        {...}  // The fourth yAxis\n    ],\n    dataZoom: [\n        { // The first dataZoom component\n            yAxisIndex: [0, 2] // Indicates that this dataZoom component\n                                     // controls the first and the third yAxis\n        },\n        { // The second dataZoom component\n            yAxisIndex: 3      // indicates that this dataZoom component\n                                     // controls the fourth yAxis\n        }\n    ]\n}\n</code></pre>\n","default":null},"radiusAxisIndex":{"type":["number","Array"],"description":"<p>Specify which <a href=\"#radiusAxis\">radiusAxis</a> is/are controlled by the <code class=\"codespan\">dataZoom-inside</code> when <a href=\"#polar\">polar coordinate system</a> is used.</p>\n<p>If it is set as a single <code class=\"codespan\">number</code>, one axis is controlled, while if it is set as an <code class=\"codespan\">Array</code> , multiple axes are controlled.</p>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">option: {\n    radiusAxis: [\n        {...}, // The first radiusAxis\n        {...}, // The second radiusAxis\n        {...}, // The third radiusAxis\n        {...}  // The fourth radiusAxis\n    ],\n    dataZoom: [\n        { // The first dataZoom component\n            radiusAxisIndex: [0, 2] // Indicates that this dataZoom component\n                                     // controls the first and the third radiusAxis\n        },\n        { // The second dataZoom component\n            radiusAxisIndex: 3      // indicates that this dataZoom component\n                                     // controls the fourth radiusAxis\n        }\n    ]\n}\n</code></pre>\n","default":null},"angleAxisIndex":{"type":["number","Array"],"description":"<p>Specify which <a href=\"#angleAxis\">angleAxis</a> is/are controlled by the <code class=\"codespan\">dataZoom-inside</code> when <a href=\"#polar\">polar coordinate system</a> is used.</p>\n<p>If it is set as a single <code class=\"codespan\">number</code>, one axis is controlled, while if it is set as an <code class=\"codespan\">Array</code> , multiple axes are controlled.</p>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">option: {\n    angleAxis: [\n        {...}, // The first angleAxis\n        {...}, // The second angleAxis\n        {...}, // The third angleAxis\n        {...}  // The fourth angleAxis\n    ],\n    dataZoom: [\n        { // The first dataZoom component\n            angleAxisIndex: [0, 2] // Indicates that this dataZoom component\n                                     // controls the first and the third angleAxis\n        },\n        { // The second dataZoom component\n            angleAxisIndex: 3      // indicates that this dataZoom component\n                                     // controls the fourth angleAxis\n        }\n    ]\n}\n</code></pre>\n","default":null},"filterMode":{"type":["string"],"description":"\n\n\n\n<p>Generally <code class=\"codespan\">dataZoom</code> component zoom or roam coordinate system through data filtering and set the windows of axes internally.</p>\n<p>Its behaviours vary according to filtering mode settings (<a href=\"#dataZoom.filterMode\">dataZoom.filterMode</a>).</p>\n<p>Possible values:</p>\n<ul>\n<li><p>&#39;filter&#39;: data that outside the window will be <strong>filtered</strong>, which may lead to some changes of windows of other axes. For each data item, it will be filtered if one of the relevant dimensions is out of the window.</p>\n</li>\n<li><p>&#39;weakFilter&#39;: data that outside the window will be <strong>filtered</strong>, which may lead to some changes of windows of other axes. For each data item, it will be filtered only if all of the relevant dimensions are out of the same side of the window.</p>\n</li>\n<li><p>&#39;empty&#39;: data that outside the window will be <strong>set to NaN</strong>, which will not lead to changes of windows of other axes.</p>\n</li>\n<li><p>&#39;none&#39;: Do not filter data.</p>\n</li>\n</ul>\n<p>How to set <code class=\"codespan\">filterMode</code> is up to users, depending on the requirments and scenarios. Expirically:</p>\n<ul>\n<li><p>If only <code class=\"codespan\">xAxis</code> or only <code class=\"codespan\">yAxis</code> is controlled by <code class=\"codespan\">dataZoom</code>, <code class=\"codespan\">filterMode: &#39;filter&#39;</code> is typically used, which enable the other axis auto adapte its window to the extent of the filtered data.</p>\n</li>\n<li><p>If both <code class=\"codespan\">xAxis</code> and <code class=\"codespan\">yAxis</code> are operated by <code class=\"codespan\">dataZoom</code>:</p>\n<ul>\n<li><p>If <code class=\"codespan\">xAxis</code> and <code class=\"codespan\">yAxis</code> should not effect mutually (e.g. a scatter chart with both axes on the type of <code class=\"codespan\">&#39;value&#39;</code>), they should be set to be <code class=\"codespan\">filterMode: &#39;empty&#39;</code>.</p>\n</li>\n<li><p>If <code class=\"codespan\">xAxis</code> is the main axis and <code class=\"codespan\">yAxis</code> is the auxiliary axis (or vise versa) (e.g., in a bar chart, when dragging <code class=\"codespan\">dataZoomX</code> to change the window of xAxis, we need the yAxis to adapt to the clipped data, but when dragging <code class=\"codespan\">dataZoomY</code> to change the window of yAxis, we need the xAxis not to be changed), in this case, <code class=\"codespan\">xAxis</code> should be set to be <code class=\"codespan\">fiterMode: &#39;filter&#39;</code>, while <code class=\"codespan\">yAxis</code> should be set to be <code class=\"codespan\">fiterMode: &#39;empty&#39;</code>.</p>\n</li>\n</ul>\n</li>\n</ul>\n<p>It can be demonstrated by the sample:</p>\n<pre><code class=\"lang-javascript\">option = {\n    dataZoom: [\n        {\n            id: &#39;dataZoomX&#39;,\n            type: &#39;slider&#39;,\n            xAxisIndex: [0],\n            filterMode: &#39;filter&#39;\n        },\n        {\n            id: &#39;dataZoomY&#39;,\n            type: &#39;slider&#39;,\n            yAxisIndex: [0],\n            filterMode: &#39;empty&#39;\n        }\n    ],\n    xAxis: {type: &#39;value&#39;},\n    yAxis: {type: &#39;value&#39;},\n    series{\n        type: &#39;bar&#39;,\n        data: [\n            // The first column corresponds to xAxis,\n            // and the second coloum corresponds to yAxis.\n            [12, 24, 36],\n            [90, 80, 70],\n            [3, 9, 27],\n            [1, 11, 111]\n        ]\n    }\n}\n</code></pre>\n<p>In the sample above, <code class=\"codespan\">dataZoomX</code> is set as <code class=\"codespan\">filterMode: &#39;filter&#39;</code>. When use drags <code class=\"codespan\">dataZoomX</code> (do not touch <code class=\"codespan\">dataZoomY</code>) and the valueWindow of <code class=\"codespan\">xAxis</code> is changed to <code class=\"codespan\">[2, 50]</code> consequently, <code class=\"codespan\">dataZoomX</code> travel the first column of series.data and filter items that out of the window. The series.data turns out to be:</p>\n<pre><code class=\"lang-javascript\">[\n    [12, 24, 36],\n    // [90, 80, 70] This item is filtered, as 90 is out of the window.\n    [3, 9, 27]\n    // [1, 11, 111] This item is filtered, as 1 is out of the window.\n]\n</code></pre>\n<p>Before filtering, the second column, which corresponds to yAxis, has values <code class=\"codespan\">24</code>, <code class=\"codespan\">80</code>, <code class=\"codespan\">9</code>, <code class=\"codespan\">11</code>. After filtering, only <code class=\"codespan\">24</code> and <code class=\"codespan\">9</code> are left. Then the extent of <code class=\"codespan\">yAxis</code> is adjusted to adapt the two values (if <code class=\"codespan\">yAxis.min</code> and <code class=\"codespan\">yAxis.max</code> are not set).</p>\n<p>So <code class=\"codespan\">filterMode: &#39;filter&#39;</code> can be used to enable the other axis to auto adapt the filtered data.</p>\n<p>Then let&#39;s review the sample from the beginning, <code class=\"codespan\">dataZoomY</code> is set as <code class=\"codespan\">filterMode: &#39;empty&#39;</code>. So if user drags <code class=\"codespan\">dataZoomY</code> (do not touch <code class=\"codespan\">dataZoomX</code>) and its window is changed to <code class=\"codespan\">[10, 60]</code> consequently, <code class=\"codespan\">dataZoomY</code> travels the second column of series.data and set NaN to all of the values that outside the window (NaN cause the graphical elements, i.e., bar elements, do not show, but still hold the place). The series.data turns out to be:</p>\n<pre><code class=\"lang-javascript\">[\n    [12, 24, 36],\n    [90, NaN, 70], // Set to NaN\n    [3, NaN, 27],  // Set to NaN\n    [1, 11, 111]\n]\n</code></pre>\n<p>In this case, the first column (i.e., <code class=\"codespan\">12</code>, <code class=\"codespan\">90</code>, <code class=\"codespan\">3</code>, <code class=\"codespan\">1</code>, which corresponds to <code class=\"codespan\">xAxis</code>), will not be changed at all. So dragging <code class=\"codespan\">yAxis</code> will not change extent of <code class=\"codespan\">xAxis</code>, which is good for requirements like outlier filtering.</p>\n<p>See this example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/bar-dataZoom-filterMode&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n\n\n\n","uiControl":{"type":"enum","options":"filter,weakFilter,empty,none","default":"filter"},"default":"'filter'"},"start":{"type":["number"],"description":"\n\n<p>The start percentage of the window out of the data extent, in the range of 0 ~ 100.</p>\n<p><a href=\"#dataZoom-inside.start\">dataZoom-inside.start</a> and <a href=\"#dataZoom-inside.end\">dataZoom-inside.end</a> define the window of the data in <strong>percent</strong> form.</p>\n<p>More info about the relationship between <code class=\"codespan\">dataZoom-inside.start</code> and axis extent can be checked in <a href=\"#dataZoom-inside.rangeMode\">dataZoom-inside.rangeMode</a>.</p>\n","uiControl":{"type":"number","min":"0","max":"100","step":"0.5"},"default":0},"end":{"type":["number"],"description":"\n\n<p>The end percentage of the window out of the data extent, in the range of 0 ~ 100.</p>\n<p><a href=\"#dataZoom-inside.start\">dataZoom-inside.start</a> and <a href=\"#dataZoom-inside.end\">dataZoom-inside.end</a> define the window of the data in <strong>percent</strong> form.</p>\n<p>More info about the relationship between <code class=\"codespan\">dataZoom-inside.end</code> and axis extent can be checked in <a href=\"#dataZoom-inside.rangeMode\">dataZoom-inside.rangeMode</a>.</p>\n","uiControl":{"type":"number","min":"0","max":"100","default":"100","step":"0.5"},"default":100},"startValue":{"type":["number","string","Date"],"description":"<p>The start absolute value of the window, not works when <a href=\"#dataZoom-inside.start\">dataZoom-inside.start</a> is set.</p>\n<p><a href=\"#dataZoom-inside.startValue\">dataZoom-inside.startValue</a> and <a href=\"#dataZoom-inside.endValue\">dataZoom-inside.endValue</a> define the window of the data window in <strong>absolute value</strong> form.</p>\n<p>Notice, if an axis is set to be <code class=\"codespan\">category</code>, <code class=\"codespan\">startValue</code> could be set as <code class=\"codespan\">index</code> of the array of <code class=\"codespan\">axis.data</code> or as the array value itself. In the latter case, it will internally and automatically translate to the index of array.</p>\n<p>More info about the relationship between <code class=\"codespan\">dataZoom-inside.startValue</code> and axis extent can be checked in <a href=\"#dataZoom-inside.rangeMode\">dataZoom-inside.rangeMode</a>.</p>\n","default":null},"endValue":{"type":["number","string","Date"],"description":"<p>The end absolute value of the window, doesn&#39;t work when <a href=\"#dataZoom-inside.end\">dataZoom-inside.end</a> is set.</p>\n<p><a href=\"#dataZoom-inside.startValue\">dataZoom-inside.startValue</a> and <a href=\"#dataZoom-inside.endValue\">dataZoom-inside.endValue</a> define the window of the data window in <strong>absolute value</strong> form.</p>\n<p>Notice, if an axis is set to be <code class=\"codespan\">category</code>, <code class=\"codespan\">startValue</code> could be set as <code class=\"codespan\">index</code> of the array of <code class=\"codespan\">axis.data</code> or as the array value itself. In the latter case, it will internally and automatically translate to the index of array.</p>\n<p>More info about the relationship between <code class=\"codespan\">dataZoom-inside.endValue</code> and axis extent can be checked in <a href=\"#dataZoom-inside.rangeMode\">dataZoom-inside.rangeMode</a>.</p>\n","default":null},"minSpan":{"type":["number"],"description":"\n\n<p>Used to restrict minimal window size, in percent, which value is in the range of [0, 100].</p>\n<p>If <a href=\"#dataZoom-inside.minValueSpan\">dataZoom-inside.minValueSpan</a> is set, <code class=\"codespan\">minSpan</code> does not work any more.</p>\n","uiControl":{"type":"number","min":"0","max":"100","step":"0.5"},"default":null},"maxSpan":{"type":["number"],"description":"\n\n<p>Used to restrict maximal window size, in percent, which value is in the range of [0, 100].</p>\n<p>If <a href=\"#dataZoom-inside.maxValueSpan\">dataZoom-inside.maxValueSpan</a> is set, <code class=\"codespan\">maxSpan</code> does not work any more.</p>\n","uiControl":{"type":"number","min":"0","max":"100","step":"0.5"},"default":null},"minValueSpan":{"type":["number","string","Date"],"description":"<p>Used to restrict minimal window size.</p>\n<p>For example:\nIn time axis it can be set as <code class=\"codespan\">3600 * 24 * 1000 * 5</code> to represent &quot;5 day&quot;.\nIn category axis it can be set as <code class=\"codespan\">5</code> to represent 5 categories.</p>\n","default":null},"maxValueSpan":{"type":["number","string","Date"],"description":"<p>Used to restrict maximal window size.</p>\n<p>For example:\nIn time axis it can be set as <code class=\"codespan\">3600 * 24 * 1000 * 5</code> to represent &quot;5 day&quot;.\nIn category axis it can be set as <code class=\"codespan\">5</code> to represent 5 categories.</p>\n","default":null},"orient":{"type":["string"],"description":"\n\n<p>Specify whether the layout of <code class=\"codespan\">dataZoom</code> component is horizontal or vertical. What&#39;s more, it indicates whether the horizontal axis or vertical axis is controlled by default in catesian coordinate system.</p>\n<p>Valid values:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;horizontal&#39;</code>: horizontal.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;vertical&#39;</code>: vertical.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"horizontal,vertical"},"default":null},"zoomLock":{"type":["boolean"],"description":"\n\n<p>Specify whether to lock the size of window (selected area).</p>\n<p>When set as <code class=\"codespan\">true</code>, the size of window is locked, that is, only the translation (by mouse drag or touch drag) is avialable but zoom is not.</p>\n","uiControl":{"type":"boolean"},"default":false},"throttle":{"type":["number"],"description":"\n\n<p>Specify the frame rate of views refreshing, with unit millisecond (ms).</p>\n<p>If <a href=\"#animation\">animation</a> set as <code class=\"codespan\">true</code> and <a href=\"#animationDurationUpdate\">animationDurationUpdate</a> set as bigger than <code class=\"codespan\">0</code>, you can keep <code class=\"codespan\">throttle</code> as the default value <code class=\"codespan\">100</code> (or set it as a value bigger than <code class=\"codespan\">0</code>), otherwise it might be not smooth when dragging.</p>\n<p>If <a href=\"#animation\">animation</a> set as <code class=\"codespan\">false</code> or <a href=\"#animationDurationUpdate\">animationDurationUpdate</a> set as <code class=\"codespan\">0</code>, and data size is not very large, and it seems to be not smooth when dragging, you can set <code class=\"codespan\">throttle</code> as <code class=\"codespan\">0</code> to improve that.</p>\n","uiControl":{"type":"number","default":"100","min":"0","step":"20"},"default":100},"rangeMode":{"type":["Array"],"description":"<p>The format is <code class=\"codespan\">[rangeModeForStart, rangeModeForEnd]</code>.</p>\n<p>For example <code class=\"codespan\">rangeMode: [&#39;value&#39;, &#39;percent&#39;]</code> means that use absolute value in <code class=\"codespan\">start</code> and percent value in <code class=\"codespan\">end</code>.</p>\n<p>Optional value for each item: <code class=\"codespan\">&#39;value&#39;</code>, <code class=\"codespan\">&#39;percent&#39;</code>.</p>\n<ul>\n<li><code class=\"codespan\">&#39;value&#39;</code> mode: the axis extent will always only be determined by <code class=\"codespan\">dataZoom.startValue</code> and <code class=\"codespan\">dataZoom.endValue</code>, despite how data like and how <code class=\"codespan\">axis.min</code> and <code class=\"codespan\">axis.max</code> are.</li>\n<li><code class=\"codespan\">&#39;percent&#39;</code> mode: <code class=\"codespan\">100</code> represents 100% of the <code class=\"codespan\">[dMin, dMax]</code>, where <code class=\"codespan\">dMin</code> is <code class=\"codespan\">axis.min</code> if <code class=\"codespan\">axis.min</code> specified, otherwise <code class=\"codespan\">data.extent[0]</code>, and <code class=\"codespan\">dMax</code> is <code class=\"codespan\">axis.max</code> if <code class=\"codespan\">axis.max</code> specified, otherwise <code class=\"codespan\">data.extent[1]</code>. Axis extent will only be determined by the result of the percent of <code class=\"codespan\">[dMin, dMax]</code>.</li>\n</ul>\n<p><code class=\"codespan\">rangeMode</code> are auto determined by whether <code class=\"codespan\">option.start</code>/<code class=\"codespan\">option.end</code> are specified (represents <code class=\"codespan\">&#39;percent&#39;</code> mode) or <code class=\"codespan\">option.startValue</code>/<code class=\"codespan\">option.endValue</code> specified (represents <code class=\"codespan\">&#39;value&#39;</code> mode). And when user behavior trigger the changing of the view, the <code class=\"codespan\">rangeMode</code> would be modified automatically. For example, if triggered by <code class=\"codespan\">toolbox.dataZoom</code>, it will be modefied to <code class=\"codespan\">&#39;value&#39;</code>, and if triggered by <code class=\"codespan\">dataZoom-inside</code> or <code class=\"codespan\">dataZoom-slider</code>, it will be modified to <code class=\"codespan\">&#39;percent&#39;</code>.</p>\n<p>If we specify <code class=\"codespan\">rangeMode</code> manually in <code class=\"codespan\">option</code>, it only works when both <code class=\"codespan\">start</code> and <code class=\"codespan\">startValue</code> specified or both <code class=\"codespan\">end</code> and <code class=\"codespan\">endValue</code> specified. So usually we do not need to specify <code class=\"codespan\">dataZoom.rangeMode</code> manually.</p>\n<p>Take a scenario as an example. When we are using dynamic data (update data periodically via <code class=\"codespan\">setOption</code>), if in <code class=\"codespan\">&#39;value</code>&#39; mode, the window will be kept in a fixed value range despite how data are appended, while if in <code class=\"codespan\">&#39;percent&#39;</code> mode, whe window range will be changed alone with the appended data (suppose <code class=\"codespan\">axis.min</code> and <code class=\"codespan\">axis.max</code> are not specified).</p>\n"},"zoomOnMouseWheel":{"type":["boolean","string"],"description":"\n\n<p>How to trigger zoom. Optional values:</p>\n<ul>\n<li><code class=\"codespan\">true</code>：Mouse wheel triggers zoom.</li>\n<li><code class=\"codespan\">false</code>：Mouse wheel can not triggers zoom.</li>\n<li><code class=\"codespan\">&#39;shift&#39;</code>：Holding <code class=\"codespan\">shift</code> and mouse wheel triggers zoom.</li>\n<li><code class=\"codespan\">&#39;ctrl&#39;</code>：Holding <code class=\"codespan\">ctrl</code> and mouse wheel triggers zoom.</li>\n<li><code class=\"codespan\">&#39;alt&#39;</code>：Holding <code class=\"codespan\">alt</code> and mouse wheel triggers zoom.</li>\n</ul>\n","uiControl":{"type":"enum","options":"true,false,shift,ctrl,alt","default":"true"},"default":true},"moveOnMouseMove":{"type":["boolean","string"],"description":"\n\n<p>How to trigger data window move. Optional values:</p>\n<ul>\n<li><code class=\"codespan\">true</code>：Mouse move triggers data window move.</li>\n<li><code class=\"codespan\">false</code>：Mouse move can not triggers data window move.</li>\n<li><code class=\"codespan\">&#39;shift&#39;</code>：Holding <code class=\"codespan\">shift</code> and mouse move triggers data window move.</li>\n<li><code class=\"codespan\">&#39;ctrl&#39;</code>：Holding <code class=\"codespan\">ctrl</code> and mouse move triggers data window move.</li>\n<li><code class=\"codespan\">&#39;alt&#39;</code>：Holding <code class=\"codespan\">alt</code> and mouse move triggers data window move.</li>\n</ul>\n","uiControl":{"type":"enum","options":"true,false,shift,ctrl,alt","default":"true"},"default":true},"moveOnMouseWheel":{"type":["boolean","string"],"description":"\n\n<p>How to trigger data window move. Optional values:</p>\n<ul>\n<li><code class=\"codespan\">true</code>：Mouse wheel triggers data window move.</li>\n<li><code class=\"codespan\">false</code>：Mouse wheel can not triggers data window move.</li>\n<li><code class=\"codespan\">&#39;shift&#39;</code>：Holding <code class=\"codespan\">shift</code> and mouse wheel triggers data window move.</li>\n<li><code class=\"codespan\">&#39;ctrl&#39;</code>：Holding <code class=\"codespan\">ctrl</code> and mouse wheel triggers data window move.</li>\n<li><code class=\"codespan\">&#39;alt&#39;</code>：Holding <code class=\"codespan\">alt</code> and mouse wheel triggers data window move.</li>\n</ul>\n","uiControl":{"type":"enum","options":"true,false,shift,ctrl,alt","default":"true"},"default":false},"preventDefaultMouseMove":{"type":["boolean"],"description":"\n\n<p>Whether to prevent default behavior of mouse move event.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true}}},{"type":["Object"],"description":"<p>Slider type dataZoom component provides functions like data thumbnail, zoom, brush to select, drag to move, click to locate.</p>\n<p>The followling picture shows areas to interact.</p>\n<p><img width=\"600\" height=\"auto\" src=\"documents/asset/img/dataZoom-zone.png\"></p>\n","properties":{"type":{"type":["string"],"description":"","default":"'slider'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the  component. If is set to be <code class=\"codespan\">false</code>, it will not show, but its data filtering function still works.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"backgroundColor":{"type":["Color"],"description":"\n\n<p>The background color of the component.</p>\n","uiControl":{"type":"color","default":"rgba(47,69,84,0)"},"default":"'rgba(47,69,84,0)'"},"dataBackground":{"type":["Object"],"description":"<p>The style of data shadow.</p>\n","properties":{"lineStyle":{"type":["Object"],"description":"<p>Line style of data shadow</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#d2dbee"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"0.5","min":"0","step":"0.5"},"default":0.5},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"areaStyle":{"type":["Object"],"description":"<p>Area style of data shadow</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"d2dbee"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"0.2","min":"0","max":"1","step":"0.01"},"default":0.2}}}}},"selectedDataBackground":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Styles of selected data shadow.</p>\n","properties":{"lineStyle":{"type":["Object"],"description":"<p>Line style of selected data shadow.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#8fb0f7"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"0.5","min":"0","step":"0.5"},"default":0.5},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"areaStyle":{"type":["Object"],"description":"<p>Area style of selected data shadow.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#8fb0f7"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"0.2","min":"0","max":"1","step":"0.01"},"default":0.2}}}}},"fillerColor":{"type":["Color"],"description":"\n\n<p>The color to fill selected area.</p>\n","uiControl":{"type":"color","default":"rgba(167,183,204,0.4)"},"default":"'rgba(47,69,84,0.25)'"},"borderColor":{"type":["Color"],"description":"\n\n<p>The color of border.</p>\n","uiControl":{"type":"color","default":"#ddd"},"default":"'#ddd'"},"handleIcon":{"type":["string"],"description":"\n\n<p>Icon shape of handle, which supports path string. Its default value is:</p>\n<pre><code class=\"lang-js\">&#39;M8.2,13.6V3.9H6.3v9.7H3.1v14.9h3.3v9.7h1.8v-9.7h3.3V13.6H8.2z M9.7,24.4H4.8v-1.4h4.9V24.4z M9.7,19.1H4.8v-1.4h4.9V19.1z&#39;\n</code></pre>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon"}},"handleSize":{"type":["number","string"],"description":"\n\n<p>The size of control handle. It can be in pixels, or in percentage relative to the width of dataZoom component. By default, it&#39;s the same as the width of dataZoom component.</p>\n","uiControl":{"type":"percent","min":"0","step":"1","default":"100%"},"default":"'100%'"},"handleStyle":{"type":["Object"],"description":"<p>Style of handle. Please refer to <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=area-simple\" target=\"_blank\">area-simple example</a>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#fff"},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"#ACB8D1"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"moveHandleIcon":{"type":["string"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Icon of move handle.</p>\n<pre><code class=\"lang-js\">&#39;M-320.9-50L-320.9-50c18.1,0,27.1,9,27.1,27.1V85.7c0,18.1-9,27.1-27.1,27.1l0,0c-18.1,0-27.1-9-27.1-27.1V-22.9C-348-41-339-50-320.9-50z M-212.3-50L-212.3-50c18.1,0,27.1,9,27.1,27.1V85.7c0,18.1-9,27.1-27.1,27.1l0,0c-18.1,0-27.1-9-27.1-27.1V-22.9C-239.4-41-230.4-50-212.3-50z M-103.7-50L-103.7-50c18.1,0,27.1,9,27.1,27.1V85.7c0,18.1-9,27.1-27.1,27.1l0,0c-18.1,0-27.1-9-27.1-27.1V-22.9C-130.9-41-121.8-50-103.7-50z&#39;\n</code></pre>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon"}},"moveHandleSize":{"type":["number"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Size of move handle.</p>\n","uiControl":{"type":"number","min":"0","step":"1","default":"7"},"default":7},"moveHandleStyle":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#D2DBEE"},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"labelPrecision":{"type":["number","string"],"description":"\n\n<p>Precision of label if in number form. By default, it is decided based on the number of data.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"labelFormatter":{"type":["string","Function"],"description":"<p>The formatter tool for the label.</p>\n<ul>\n<li><p>It is a template if in <code class=\"codespan\">string</code>. For instance, <code class=\"codespan\">aaaa{value}bbbb</code>, where <code class=\"codespan\">{value}</code> will be replaced by the value of actual data value.</p>\n</li>\n<li><p>It is a callback function if in <code class=\"codespan\">Function</code>. For example:</p>\n</li>\n</ul>\n<pre><code class=\"lang-javascript\">/**\n * @param {*} value If axis.type is &#39;category&#39;, `value` is the index of axis.data.\n *                  else `value` is current value.\n * @param {strign} valueStr Inner formatted string.\n * @return {string} Returns the label formatted.\n */\nlabelFormatter: function (value, valueStr) {\n    return &#39;aaa&#39; + value + &#39;bbb&#39;;\n}\n</code></pre>\n","default":null},"showDetail":{"type":["boolean"],"description":"\n\n<p>Whether to show detail, that is, show the detailed data information when dragging.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"showDataShadow":{"type":["string"],"description":"\n\n<p>Whether to show data shadow in <code class=\"codespan\">dataZoom-silder</code> component, to indicate the data tendency in brief.</p>\n","uiControl":{"type":"boolean"},"default":"'auto'"},"realtime":{"type":["boolean"],"description":"\n\n<p>Whether to update view while dragging. If it is set as <code class=\"codespan\">false</code>, the view will be updated only at the end of dragging.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"textStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>dataZoom  text color.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"#333"},"fontStyle":{"type":["string"],"description":"\n\n<p>dataZoom  font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p>dataZoom  font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p>dataZoom  font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p>dataZoom  font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"xAxisIndex":{"type":["number","Array"],"description":"<p>Specify which <a href=\"#xAxis\">xAxis</a> is/are controlled by the <code class=\"codespan\">dataZoom-slider</code> when <a href=\"#grid\">catesian coordinate system</a> is used.</p>\n<p>By default the first <code class=\"codespan\">xAxis</code> that parallel to <code class=\"codespan\">dataZoom</code> are controlled when <a href=\"#dataZoom-slider.orient\">dataZoom-slider.orient</a> is set as <code class=\"codespan\">&#39;horizontal&#39;</code>. But it is recommended to specify it explicitly but not use default value.</p>\n<p>If it is set as a single <code class=\"codespan\">number</code>, one axis is controlled, while if it is set as an <code class=\"codespan\">Array</code> , multiple axes are controlled.</p>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">option: {\n    xAxis: [\n        {...}, // The first xAxis\n        {...}, // The second xAxis\n        {...}, // The third xAxis\n        {...}  // The fourth xAxis\n    ],\n    dataZoom: [\n        { // The first dataZoom component\n            xAxisIndex: [0, 2] // Indicates that this dataZoom component\n                                     // controls the first and the third xAxis\n        },\n        { // The second dataZoom component\n            xAxisIndex: 3      // indicates that this dataZoom component\n                                     // controls the fourth xAxis\n        }\n    ]\n}\n</code></pre>\n","default":null},"yAxisIndex":{"type":["number","Array"],"description":"<p>Specify which <a href=\"#yAxis\">yAxis</a> is/are controlled by the <code class=\"codespan\">dataZoom-slider</code> when <a href=\"#grid\">catesian coordinate system</a> is used.</p>\n<p>By default the first <code class=\"codespan\">yAxis</code> that parallel to <code class=\"codespan\">dataZoom</code> are controlled when <a href=\"#dataZoom-slider.orient\">dataZoom-slider.orient</a> is set as <code class=\"codespan\">&#39;vertical&#39;</code>. But it is recommended to specify it explicitly but not use default value.</p>\n<p>If it is set as a single <code class=\"codespan\">number</code>, one axis is controlled, while if it is set as an <code class=\"codespan\">Array</code> , multiple axes are controlled.</p>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">option: {\n    yAxis: [\n        {...}, // The first yAxis\n        {...}, // The second yAxis\n        {...}, // The third yAxis\n        {...}  // The fourth yAxis\n    ],\n    dataZoom: [\n        { // The first dataZoom component\n            yAxisIndex: [0, 2] // Indicates that this dataZoom component\n                                     // controls the first and the third yAxis\n        },\n        { // The second dataZoom component\n            yAxisIndex: 3      // indicates that this dataZoom component\n                                     // controls the fourth yAxis\n        }\n    ]\n}\n</code></pre>\n","default":null},"radiusAxisIndex":{"type":["number","Array"],"description":"<p>Specify which <a href=\"#radiusAxis\">radiusAxis</a> is/are controlled by the <code class=\"codespan\">dataZoom-slider</code> when <a href=\"#polar\">polar coordinate system</a> is used.</p>\n<p>If it is set as a single <code class=\"codespan\">number</code>, one axis is controlled, while if it is set as an <code class=\"codespan\">Array</code> , multiple axes are controlled.</p>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">option: {\n    radiusAxis: [\n        {...}, // The first radiusAxis\n        {...}, // The second radiusAxis\n        {...}, // The third radiusAxis\n        {...}  // The fourth radiusAxis\n    ],\n    dataZoom: [\n        { // The first dataZoom component\n            radiusAxisIndex: [0, 2] // Indicates that this dataZoom component\n                                     // controls the first and the third radiusAxis\n        },\n        { // The second dataZoom component\n            radiusAxisIndex: 3      // indicates that this dataZoom component\n                                     // controls the fourth radiusAxis\n        }\n    ]\n}\n</code></pre>\n","default":null},"angleAxisIndex":{"type":["number","Array"],"description":"<p>Specify which <a href=\"#angleAxis\">angleAxis</a> is/are controlled by the <code class=\"codespan\">dataZoom-slider</code> when <a href=\"#polar\">polar coordinate system</a> is used.</p>\n<p>If it is set as a single <code class=\"codespan\">number</code>, one axis is controlled, while if it is set as an <code class=\"codespan\">Array</code> , multiple axes are controlled.</p>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">option: {\n    angleAxis: [\n        {...}, // The first angleAxis\n        {...}, // The second angleAxis\n        {...}, // The third angleAxis\n        {...}  // The fourth angleAxis\n    ],\n    dataZoom: [\n        { // The first dataZoom component\n            angleAxisIndex: [0, 2] // Indicates that this dataZoom component\n                                     // controls the first and the third angleAxis\n        },\n        { // The second dataZoom component\n            angleAxisIndex: 3      // indicates that this dataZoom component\n                                     // controls the fourth angleAxis\n        }\n    ]\n}\n</code></pre>\n","default":null},"filterMode":{"type":["string"],"description":"\n\n\n\n<p>Generally <code class=\"codespan\">dataZoom</code> component zoom or roam coordinate system through data filtering and set the windows of axes internally.</p>\n<p>Its behaviours vary according to filtering mode settings (<a href=\"#dataZoom.filterMode\">dataZoom.filterMode</a>).</p>\n<p>Possible values:</p>\n<ul>\n<li><p>&#39;filter&#39;: data that outside the window will be <strong>filtered</strong>, which may lead to some changes of windows of other axes. For each data item, it will be filtered if one of the relevant dimensions is out of the window.</p>\n</li>\n<li><p>&#39;weakFilter&#39;: data that outside the window will be <strong>filtered</strong>, which may lead to some changes of windows of other axes. For each data item, it will be filtered only if all of the relevant dimensions are out of the same side of the window.</p>\n</li>\n<li><p>&#39;empty&#39;: data that outside the window will be <strong>set to NaN</strong>, which will not lead to changes of windows of other axes.</p>\n</li>\n<li><p>&#39;none&#39;: Do not filter data.</p>\n</li>\n</ul>\n<p>How to set <code class=\"codespan\">filterMode</code> is up to users, depending on the requirments and scenarios. Expirically:</p>\n<ul>\n<li><p>If only <code class=\"codespan\">xAxis</code> or only <code class=\"codespan\">yAxis</code> is controlled by <code class=\"codespan\">dataZoom</code>, <code class=\"codespan\">filterMode: &#39;filter&#39;</code> is typically used, which enable the other axis auto adapte its window to the extent of the filtered data.</p>\n</li>\n<li><p>If both <code class=\"codespan\">xAxis</code> and <code class=\"codespan\">yAxis</code> are operated by <code class=\"codespan\">dataZoom</code>:</p>\n<ul>\n<li><p>If <code class=\"codespan\">xAxis</code> and <code class=\"codespan\">yAxis</code> should not effect mutually (e.g. a scatter chart with both axes on the type of <code class=\"codespan\">&#39;value&#39;</code>), they should be set to be <code class=\"codespan\">filterMode: &#39;empty&#39;</code>.</p>\n</li>\n<li><p>If <code class=\"codespan\">xAxis</code> is the main axis and <code class=\"codespan\">yAxis</code> is the auxiliary axis (or vise versa) (e.g., in a bar chart, when dragging <code class=\"codespan\">dataZoomX</code> to change the window of xAxis, we need the yAxis to adapt to the clipped data, but when dragging <code class=\"codespan\">dataZoomY</code> to change the window of yAxis, we need the xAxis not to be changed), in this case, <code class=\"codespan\">xAxis</code> should be set to be <code class=\"codespan\">fiterMode: &#39;filter&#39;</code>, while <code class=\"codespan\">yAxis</code> should be set to be <code class=\"codespan\">fiterMode: &#39;empty&#39;</code>.</p>\n</li>\n</ul>\n</li>\n</ul>\n<p>It can be demonstrated by the sample:</p>\n<pre><code class=\"lang-javascript\">option = {\n    dataZoom: [\n        {\n            id: &#39;dataZoomX&#39;,\n            type: &#39;slider&#39;,\n            xAxisIndex: [0],\n            filterMode: &#39;filter&#39;\n        },\n        {\n            id: &#39;dataZoomY&#39;,\n            type: &#39;slider&#39;,\n            yAxisIndex: [0],\n            filterMode: &#39;empty&#39;\n        }\n    ],\n    xAxis: {type: &#39;value&#39;},\n    yAxis: {type: &#39;value&#39;},\n    series{\n        type: &#39;bar&#39;,\n        data: [\n            // The first column corresponds to xAxis,\n            // and the second coloum corresponds to yAxis.\n            [12, 24, 36],\n            [90, 80, 70],\n            [3, 9, 27],\n            [1, 11, 111]\n        ]\n    }\n}\n</code></pre>\n<p>In the sample above, <code class=\"codespan\">dataZoomX</code> is set as <code class=\"codespan\">filterMode: &#39;filter&#39;</code>. When use drags <code class=\"codespan\">dataZoomX</code> (do not touch <code class=\"codespan\">dataZoomY</code>) and the valueWindow of <code class=\"codespan\">xAxis</code> is changed to <code class=\"codespan\">[2, 50]</code> consequently, <code class=\"codespan\">dataZoomX</code> travel the first column of series.data and filter items that out of the window. The series.data turns out to be:</p>\n<pre><code class=\"lang-javascript\">[\n    [12, 24, 36],\n    // [90, 80, 70] This item is filtered, as 90 is out of the window.\n    [3, 9, 27]\n    // [1, 11, 111] This item is filtered, as 1 is out of the window.\n]\n</code></pre>\n<p>Before filtering, the second column, which corresponds to yAxis, has values <code class=\"codespan\">24</code>, <code class=\"codespan\">80</code>, <code class=\"codespan\">9</code>, <code class=\"codespan\">11</code>. After filtering, only <code class=\"codespan\">24</code> and <code class=\"codespan\">9</code> are left. Then the extent of <code class=\"codespan\">yAxis</code> is adjusted to adapt the two values (if <code class=\"codespan\">yAxis.min</code> and <code class=\"codespan\">yAxis.max</code> are not set).</p>\n<p>So <code class=\"codespan\">filterMode: &#39;filter&#39;</code> can be used to enable the other axis to auto adapt the filtered data.</p>\n<p>Then let&#39;s review the sample from the beginning, <code class=\"codespan\">dataZoomY</code> is set as <code class=\"codespan\">filterMode: &#39;empty&#39;</code>. So if user drags <code class=\"codespan\">dataZoomY</code> (do not touch <code class=\"codespan\">dataZoomX</code>) and its window is changed to <code class=\"codespan\">[10, 60]</code> consequently, <code class=\"codespan\">dataZoomY</code> travels the second column of series.data and set NaN to all of the values that outside the window (NaN cause the graphical elements, i.e., bar elements, do not show, but still hold the place). The series.data turns out to be:</p>\n<pre><code class=\"lang-javascript\">[\n    [12, 24, 36],\n    [90, NaN, 70], // Set to NaN\n    [3, NaN, 27],  // Set to NaN\n    [1, 11, 111]\n]\n</code></pre>\n<p>In this case, the first column (i.e., <code class=\"codespan\">12</code>, <code class=\"codespan\">90</code>, <code class=\"codespan\">3</code>, <code class=\"codespan\">1</code>, which corresponds to <code class=\"codespan\">xAxis</code>), will not be changed at all. So dragging <code class=\"codespan\">yAxis</code> will not change extent of <code class=\"codespan\">xAxis</code>, which is good for requirements like outlier filtering.</p>\n<p>See this example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/bar-dataZoom-filterMode&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n\n\n\n","uiControl":{"type":"enum","options":"filter,weakFilter,empty,none","default":"filter"},"default":"'filter'"},"start":{"type":["number"],"description":"\n\n<p>The start percentage of the window out of the data extent, in the range of 0 ~ 100.</p>\n<p><a href=\"#dataZoom-slider.start\">dataZoom-slider.start</a> and <a href=\"#dataZoom-slider.end\">dataZoom-slider.end</a> define the window of the data in <strong>percent</strong> form.</p>\n<p>More info about the relationship between <code class=\"codespan\">dataZoom-slider.start</code> and axis extent can be checked in <a href=\"#dataZoom-slider.rangeMode\">dataZoom-slider.rangeMode</a>.</p>\n","uiControl":{"type":"number","min":"0","max":"100","step":"0.5"},"default":0},"end":{"type":["number"],"description":"\n\n<p>The end percentage of the window out of the data extent, in the range of 0 ~ 100.</p>\n<p><a href=\"#dataZoom-slider.start\">dataZoom-slider.start</a> and <a href=\"#dataZoom-slider.end\">dataZoom-slider.end</a> define the window of the data in <strong>percent</strong> form.</p>\n<p>More info about the relationship between <code class=\"codespan\">dataZoom-slider.end</code> and axis extent can be checked in <a href=\"#dataZoom-slider.rangeMode\">dataZoom-slider.rangeMode</a>.</p>\n","uiControl":{"type":"number","min":"0","max":"100","default":"100","step":"0.5"},"default":100},"startValue":{"type":["number","string","Date"],"description":"<p>The start absolute value of the window, not works when <a href=\"#dataZoom-slider.start\">dataZoom-slider.start</a> is set.</p>\n<p><a href=\"#dataZoom-slider.startValue\">dataZoom-slider.startValue</a> and <a href=\"#dataZoom-slider.endValue\">dataZoom-slider.endValue</a> define the window of the data window in <strong>absolute value</strong> form.</p>\n<p>Notice, if an axis is set to be <code class=\"codespan\">category</code>, <code class=\"codespan\">startValue</code> could be set as <code class=\"codespan\">index</code> of the array of <code class=\"codespan\">axis.data</code> or as the array value itself. In the latter case, it will internally and automatically translate to the index of array.</p>\n<p>More info about the relationship between <code class=\"codespan\">dataZoom-slider.startValue</code> and axis extent can be checked in <a href=\"#dataZoom-slider.rangeMode\">dataZoom-slider.rangeMode</a>.</p>\n","default":null},"endValue":{"type":["number","string","Date"],"description":"<p>The end absolute value of the window, doesn&#39;t work when <a href=\"#dataZoom-slider.end\">dataZoom-slider.end</a> is set.</p>\n<p><a href=\"#dataZoom-slider.startValue\">dataZoom-slider.startValue</a> and <a href=\"#dataZoom-slider.endValue\">dataZoom-slider.endValue</a> define the window of the data window in <strong>absolute value</strong> form.</p>\n<p>Notice, if an axis is set to be <code class=\"codespan\">category</code>, <code class=\"codespan\">startValue</code> could be set as <code class=\"codespan\">index</code> of the array of <code class=\"codespan\">axis.data</code> or as the array value itself. In the latter case, it will internally and automatically translate to the index of array.</p>\n<p>More info about the relationship between <code class=\"codespan\">dataZoom-slider.endValue</code> and axis extent can be checked in <a href=\"#dataZoom-slider.rangeMode\">dataZoom-slider.rangeMode</a>.</p>\n","default":null},"minSpan":{"type":["number"],"description":"\n\n<p>Used to restrict minimal window size, in percent, which value is in the range of [0, 100].</p>\n<p>If <a href=\"#dataZoom-slider.minValueSpan\">dataZoom-slider.minValueSpan</a> is set, <code class=\"codespan\">minSpan</code> does not work any more.</p>\n","uiControl":{"type":"number","min":"0","max":"100","step":"0.5"},"default":null},"maxSpan":{"type":["number"],"description":"\n\n<p>Used to restrict maximal window size, in percent, which value is in the range of [0, 100].</p>\n<p>If <a href=\"#dataZoom-slider.maxValueSpan\">dataZoom-slider.maxValueSpan</a> is set, <code class=\"codespan\">maxSpan</code> does not work any more.</p>\n","uiControl":{"type":"number","min":"0","max":"100","step":"0.5"},"default":null},"minValueSpan":{"type":["number","string","Date"],"description":"<p>Used to restrict minimal window size.</p>\n<p>For example:\nIn time axis it can be set as <code class=\"codespan\">3600 * 24 * 1000 * 5</code> to represent &quot;5 day&quot;.\nIn category axis it can be set as <code class=\"codespan\">5</code> to represent 5 categories.</p>\n","default":null},"maxValueSpan":{"type":["number","string","Date"],"description":"<p>Used to restrict maximal window size.</p>\n<p>For example:\nIn time axis it can be set as <code class=\"codespan\">3600 * 24 * 1000 * 5</code> to represent &quot;5 day&quot;.\nIn category axis it can be set as <code class=\"codespan\">5</code> to represent 5 categories.</p>\n","default":null},"orient":{"type":["string"],"description":"\n\n<p>Specify whether the layout of <code class=\"codespan\">dataZoom</code> component is horizontal or vertical. What&#39;s more, it indicates whether the horizontal axis or vertical axis is controlled by default in catesian coordinate system.</p>\n<p>Valid values:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;horizontal&#39;</code>: horizontal.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;vertical&#39;</code>: vertical.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"horizontal,vertical"},"default":null},"zoomLock":{"type":["boolean"],"description":"\n\n<p>Specify whether to lock the size of window (selected area).</p>\n<p>When set as <code class=\"codespan\">true</code>, the size of window is locked, that is, only the translation (by mouse drag or touch drag) is avialable but zoom is not.</p>\n","uiControl":{"type":"boolean"},"default":false},"throttle":{"type":["number"],"description":"\n\n<p>Specify the frame rate of views refreshing, with unit millisecond (ms).</p>\n<p>If <a href=\"#animation\">animation</a> set as <code class=\"codespan\">true</code> and <a href=\"#animationDurationUpdate\">animationDurationUpdate</a> set as bigger than <code class=\"codespan\">0</code>, you can keep <code class=\"codespan\">throttle</code> as the default value <code class=\"codespan\">100</code> (or set it as a value bigger than <code class=\"codespan\">0</code>), otherwise it might be not smooth when dragging.</p>\n<p>If <a href=\"#animation\">animation</a> set as <code class=\"codespan\">false</code> or <a href=\"#animationDurationUpdate\">animationDurationUpdate</a> set as <code class=\"codespan\">0</code>, and data size is not very large, and it seems to be not smooth when dragging, you can set <code class=\"codespan\">throttle</code> as <code class=\"codespan\">0</code> to improve that.</p>\n","uiControl":{"type":"number","default":"100","min":"0","step":"20"},"default":100},"rangeMode":{"type":["Array"],"description":"<p>The format is <code class=\"codespan\">[rangeModeForStart, rangeModeForEnd]</code>.</p>\n<p>For example <code class=\"codespan\">rangeMode: [&#39;value&#39;, &#39;percent&#39;]</code> means that use absolute value in <code class=\"codespan\">start</code> and percent value in <code class=\"codespan\">end</code>.</p>\n<p>Optional value for each item: <code class=\"codespan\">&#39;value&#39;</code>, <code class=\"codespan\">&#39;percent&#39;</code>.</p>\n<ul>\n<li><code class=\"codespan\">&#39;value&#39;</code> mode: the axis extent will always only be determined by <code class=\"codespan\">dataZoom.startValue</code> and <code class=\"codespan\">dataZoom.endValue</code>, despite how data like and how <code class=\"codespan\">axis.min</code> and <code class=\"codespan\">axis.max</code> are.</li>\n<li><code class=\"codespan\">&#39;percent&#39;</code> mode: <code class=\"codespan\">100</code> represents 100% of the <code class=\"codespan\">[dMin, dMax]</code>, where <code class=\"codespan\">dMin</code> is <code class=\"codespan\">axis.min</code> if <code class=\"codespan\">axis.min</code> specified, otherwise <code class=\"codespan\">data.extent[0]</code>, and <code class=\"codespan\">dMax</code> is <code class=\"codespan\">axis.max</code> if <code class=\"codespan\">axis.max</code> specified, otherwise <code class=\"codespan\">data.extent[1]</code>. Axis extent will only be determined by the result of the percent of <code class=\"codespan\">[dMin, dMax]</code>.</li>\n</ul>\n<p><code class=\"codespan\">rangeMode</code> are auto determined by whether <code class=\"codespan\">option.start</code>/<code class=\"codespan\">option.end</code> are specified (represents <code class=\"codespan\">&#39;percent&#39;</code> mode) or <code class=\"codespan\">option.startValue</code>/<code class=\"codespan\">option.endValue</code> specified (represents <code class=\"codespan\">&#39;value&#39;</code> mode). And when user behavior trigger the changing of the view, the <code class=\"codespan\">rangeMode</code> would be modified automatically. For example, if triggered by <code class=\"codespan\">toolbox.dataZoom</code>, it will be modefied to <code class=\"codespan\">&#39;value&#39;</code>, and if triggered by <code class=\"codespan\">dataZoom-inside</code> or <code class=\"codespan\">dataZoom-slider</code>, it will be modified to <code class=\"codespan\">&#39;percent&#39;</code>.</p>\n<p>If we specify <code class=\"codespan\">rangeMode</code> manually in <code class=\"codespan\">option</code>, it only works when both <code class=\"codespan\">start</code> and <code class=\"codespan\">startValue</code> specified or both <code class=\"codespan\">end</code> and <code class=\"codespan\">endValue</code> specified. So usually we do not need to specify <code class=\"codespan\">dataZoom.rangeMode</code> manually.</p>\n<p>Take a scenario as an example. When we are using dynamic data (update data periodically via <code class=\"codespan\">setOption</code>), if in <code class=\"codespan\">&#39;value</code>&#39; mode, the window will be kept in a fixed value range despite how data are appended, while if in <code class=\"codespan\">&#39;percent&#39;</code> mode, whe window range will be changed alone with the appended data (suppose <code class=\"codespan\">axis.min</code> and <code class=\"codespan\">axis.max</code> are not specified).</p>\n"},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between dataZoom-slider component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'auto'"},"top":{"type":["string","number"],"description":"<p>Distance between dataZoom-slider component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'auto'"},"right":{"type":["string","number"],"description":"<p>Distance between dataZoom-slider component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"bottom":{"type":["string","number"],"description":"<p>Distance between dataZoom-slider component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"brushSelect":{"type":["boolean"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Whether to enable brush to select.</p>\n","default":true},"brushStyle":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Style of brushing area.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"rgba(135,175,274,0.15)"},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Style when highlighted.</p>\n","properties":{"handleStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"moveHandleStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}}]},"description":"<p><code class=\"codespan\">dataZoom</code> component is used for zooming a specific area, which enables user to investigate data in detail, or get an overview of the data, or get rid of outlier points.</p>\n<p>These types of <code class=\"codespan\">dataZoom</code> component are supported:</p>\n<ul>\n<li><p><a href=\"#dataZoom-inside\">dataZoomInside</a>: Data zoom functionalities is embeded inside coordinate systems, enable user to zoom or roam coordinate system by mouse dragging, mouse move or finger touch (in touch screen).</p>\n</li>\n<li><p><a href=\"#dataZoom-slider\">dataZoomSlider</a>: A special slider bar is provided, on which coordinate systems can be zoomed or roamed by mouse dragging or finger touch (in touch screen).</p>\n</li>\n<li><p><a href=\"#toolbox.feature.dataZoom\">dataZoomSelect</a>: A marquee tool is provided for zooming or roaming coordinate system. That is <a href=\"#toolbox.feature.dataZoom\">toolbox.feature.dataZoom</a>, which can only be configured in toolbox.</p>\n</li>\n</ul>\n<p>Example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/scatter-dataZoom-all&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n<p><br></p>\n<hr>\n<p><strong>✦ Relationship between dataZoom and axis ✦</strong></p>\n<p>Basically <code class=\"codespan\">dataZoom</code> component operates &quot;window&quot; on axis to zoom or roam coordinate system.</p>\n<blockquote>\n<p>Use <a href=\"#dataZoom.xAxisIndex\">dataZoom.xAxisIndex</a> or <a href=\"#dataZoom.yAxisIndex\">dataZoom.yAxisIndex</a> or <a href=\"#dataZoom.radiusAxisIndex\">dataZoom.radiusAxisIndex</a> or <a href=\"#dataZoom.angleAxisIndex\">dataZoom.angleAxisIndex</a> to specify which axes are operated by <code class=\"codespan\">dataZoom</code>.</p>\n</blockquote>\n<p>A single chart instance can contain several <code class=\"codespan\">dataZoom</code> components, each of which controls different axes. The <code class=\"codespan\">dataZoom</code> components that control the same axis will be automatically linked (i.e., all of them will be updated when one of them is updated by user action or API call).</p>\n<p><br></p>\n<hr>\n<p><strong>✦ How dataZoom componets operates axes and data ✦</strong></p>\n<p>Generally <code class=\"codespan\">dataZoom</code> component zoom or roam coordinate system through data filtering and set the windows of axes internally.</p>\n<p>Its behaviours vary according to filtering mode settings (<a href=\"#dataZoom.filterMode\">dataZoom.filterMode</a>).</p>\n<p>Possible values:</p>\n<ul>\n<li><p>&#39;filter&#39;: data that outside the window will be <strong>filtered</strong>, which may lead to some changes of windows of other axes. For each data item, it will be filtered if one of the relevant dimensions is out of the window.</p>\n</li>\n<li><p>&#39;weakFilter&#39;: data that outside the window will be <strong>filtered</strong>, which may lead to some changes of windows of other axes. For each data item, it will be filtered only if all of the relevant dimensions are out of the same side of the window.</p>\n</li>\n<li><p>&#39;empty&#39;: data that outside the window will be <strong>set to NaN</strong>, which will not lead to changes of windows of other axes.</p>\n</li>\n<li><p>&#39;none&#39;: Do not filter data.</p>\n</li>\n</ul>\n<p>How to set <code class=\"codespan\">filterMode</code> is up to users, depending on the requirments and scenarios. Expirically:</p>\n<ul>\n<li><p>If only <code class=\"codespan\">xAxis</code> or only <code class=\"codespan\">yAxis</code> is controlled by <code class=\"codespan\">dataZoom</code>, <code class=\"codespan\">filterMode: &#39;filter&#39;</code> is typically used, which enable the other axis auto adapte its window to the extent of the filtered data.</p>\n</li>\n<li><p>If both <code class=\"codespan\">xAxis</code> and <code class=\"codespan\">yAxis</code> are operated by <code class=\"codespan\">dataZoom</code>:</p>\n<ul>\n<li><p>If <code class=\"codespan\">xAxis</code> and <code class=\"codespan\">yAxis</code> should not effect mutually (e.g. a scatter chart with both axes on the type of <code class=\"codespan\">&#39;value&#39;</code>), they should be set to be <code class=\"codespan\">filterMode: &#39;empty&#39;</code>.</p>\n</li>\n<li><p>If <code class=\"codespan\">xAxis</code> is the main axis and <code class=\"codespan\">yAxis</code> is the auxiliary axis (or vise versa) (e.g., in a bar chart, when dragging <code class=\"codespan\">dataZoomX</code> to change the window of xAxis, we need the yAxis to adapt to the clipped data, but when dragging <code class=\"codespan\">dataZoomY</code> to change the window of yAxis, we need the xAxis not to be changed), in this case, <code class=\"codespan\">xAxis</code> should be set to be <code class=\"codespan\">fiterMode: &#39;filter&#39;</code>, while <code class=\"codespan\">yAxis</code> should be set to be <code class=\"codespan\">fiterMode: &#39;empty&#39;</code>.</p>\n</li>\n</ul>\n</li>\n</ul>\n<p>It can be demonstrated by the sample:</p>\n<pre><code class=\"lang-javascript\">option = {\n    dataZoom: [\n        {\n            id: &#39;dataZoomX&#39;,\n            type: &#39;slider&#39;,\n            xAxisIndex: [0],\n            filterMode: &#39;filter&#39;\n        },\n        {\n            id: &#39;dataZoomY&#39;,\n            type: &#39;slider&#39;,\n            yAxisIndex: [0],\n            filterMode: &#39;empty&#39;\n        }\n    ],\n    xAxis: {type: &#39;value&#39;},\n    yAxis: {type: &#39;value&#39;},\n    series{\n        type: &#39;bar&#39;,\n        data: [\n            // The first column corresponds to xAxis,\n            // and the second coloum corresponds to yAxis.\n            [12, 24, 36],\n            [90, 80, 70],\n            [3, 9, 27],\n            [1, 11, 111]\n        ]\n    }\n}\n</code></pre>\n<p>In the sample above, <code class=\"codespan\">dataZoomX</code> is set as <code class=\"codespan\">filterMode: &#39;filter&#39;</code>. When use drags <code class=\"codespan\">dataZoomX</code> (do not touch <code class=\"codespan\">dataZoomY</code>) and the valueWindow of <code class=\"codespan\">xAxis</code> is changed to <code class=\"codespan\">[2, 50]</code> consequently, <code class=\"codespan\">dataZoomX</code> travel the first column of series.data and filter items that out of the window. The series.data turns out to be:</p>\n<pre><code class=\"lang-javascript\">[\n    [12, 24, 36],\n    // [90, 80, 70] This item is filtered, as 90 is out of the window.\n    [3, 9, 27]\n    // [1, 11, 111] This item is filtered, as 1 is out of the window.\n]\n</code></pre>\n<p>Before filtering, the second column, which corresponds to yAxis, has values <code class=\"codespan\">24</code>, <code class=\"codespan\">80</code>, <code class=\"codespan\">9</code>, <code class=\"codespan\">11</code>. After filtering, only <code class=\"codespan\">24</code> and <code class=\"codespan\">9</code> are left. Then the extent of <code class=\"codespan\">yAxis</code> is adjusted to adapt the two values (if <code class=\"codespan\">yAxis.min</code> and <code class=\"codespan\">yAxis.max</code> are not set).</p>\n<p>So <code class=\"codespan\">filterMode: &#39;filter&#39;</code> can be used to enable the other axis to auto adapt the filtered data.</p>\n<p>Then let&#39;s review the sample from the beginning, <code class=\"codespan\">dataZoomY</code> is set as <code class=\"codespan\">filterMode: &#39;empty&#39;</code>. So if user drags <code class=\"codespan\">dataZoomY</code> (do not touch <code class=\"codespan\">dataZoomX</code>) and its window is changed to <code class=\"codespan\">[10, 60]</code> consequently, <code class=\"codespan\">dataZoomY</code> travels the second column of series.data and set NaN to all of the values that outside the window (NaN cause the graphical elements, i.e., bar elements, do not show, but still hold the place). The series.data turns out to be:</p>\n<pre><code class=\"lang-javascript\">[\n    [12, 24, 36],\n    [90, NaN, 70], // Set to NaN\n    [3, NaN, 27],  // Set to NaN\n    [1, 11, 111]\n]\n</code></pre>\n<p>In this case, the first column (i.e., <code class=\"codespan\">12</code>, <code class=\"codespan\">90</code>, <code class=\"codespan\">3</code>, <code class=\"codespan\">1</code>, which corresponds to <code class=\"codespan\">xAxis</code>), will not be changed at all. So dragging <code class=\"codespan\">yAxis</code> will not change extent of <code class=\"codespan\">xAxis</code>, which is good for requirements like outlier filtering.</p>\n<p>See this example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/bar-dataZoom-filterMode&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n\n\n\n\n<p>Moreover, when <code class=\"codespan\">min</code>, <code class=\"codespan\">max</code> of an axis is set (e.g., <code class=\"codespan\">yAxis: {min: 0, max: 400}</code>), this extent of the axis will not be modified by the behaviour of dataZoom of other axis any more.</p>\n<p><br></p>\n<hr>\n<p><strong>✦ How to set window ✦</strong></p>\n<p>You can set the current window in two forms:</p>\n<ul>\n<li><p>percent value: see <a href=\"#dataZoom.start\">dataZoom.start</a> and <a href=\"#dataZoom.end\">dataZoom.end</a>.</p>\n</li>\n<li><p>absolute value: see <a href=\"#dataZoom.startValue\">dataZoom.startValue</a> and <a href=\"#dataZoom.endValue\">dataZoom.endValue</a>.</p>\n</li>\n</ul>\n<p>Notice: If use percent value form, and it is in the scenario below, the result of dataZoom depends on the sequence of dataZoom definitions appearing in <code class=\"codespan\">option</code>.</p>\n<pre><code class=\"lang-javascript\">option = {\n    dataZoom: [\n        {\n            id: &#39;dataZoomX&#39;,\n            type: &#39;slider&#39;,\n            xAxisIndex: [0],\n            filterMode: &#39;filter&#39;,   // Set as &#39;filter&#39; so that the modification\n                                    // of window of xAxis willl effect the\n                                    // window of yAxis.\n            start: 30,\n            end: 70\n        },\n        {\n            id: &#39;dataZoomY&#39;,\n            type: &#39;slider&#39;,\n            yAxisIndex: [0],\n            filterMode: &#39;empty&#39;,\n            start: 20,\n            end: 80\n        }\n    ],\n    xAxis: {\n        type: &#39;value&#39;\n    },\n    yAxis: {\n        type: &#39;value&#39;\n        // Notice there is no min or max set to\n        // restrict the view extent of yAxis.\n    },\n    series{\n        type: &#39;bar&#39;,\n        data: [\n            // The first column corresponds to xAxis,\n            // and the second column corresponds to yAxis.\n            [12, 24, 36],\n            [90, 80, 70],\n            [3, 9, 27],\n            [1, 11, 111]\n        ]\n    }\n}\n</code></pre>\n<p>What is the exact meaning of <code class=\"codespan\">start: 20, end: 80</code> in <code class=\"codespan\">dataZoomY</code> in the example above?</p>\n<ul>\n<li><p>If <code class=\"codespan\">yAxis.min</code> and <code class=\"codespan\">yAxis.max</code> are set:</p>\n<p>  <code class=\"codespan\">start: 20, end: 80</code> of <code class=\"codespan\">dataZoomY</code> means: from <code class=\"codespan\">20%</code> to <code class=\"codespan\">80%</code> out of <code class=\"codespan\">[yAxis.min, yAxis.max]</code>.</p>\n<p>  If one of <code class=\"codespan\">yAxis.min</code> and <code class=\"codespan\">yAxis.max</code> is not set, the corresponding edge of the full extend also follow rule as follows.</p>\n</li>\n<li><p>If <code class=\"codespan\">yAxis.min</code> and <code class=\"codespan\">yAxis.max</code> are not set:</p>\n<ul>\n<li><p>If <code class=\"codespan\">dataZoomX</code> is set to be <code class=\"codespan\">filterMode: &#39;empty&#39;</code>:</p>\n<p>  <code class=\"codespan\">start: 20, end: 80</code> of <code class=\"codespan\">dataZoomY</code> means: from <code class=\"codespan\">20%</code> to <code class=\"codespan\">80%</code> out of <code class=\"codespan\">[dataMinY to dataMaxY]</code> of series.data (i.e., <code class=\"codespan\">[9, 80]</code> in the example above).</p>\n</li>\n<li><p>If <code class=\"codespan\">dataZoomX</code> is set to <code class=\"codespan\">filterMode: &#39;filter&#39;</code>:</p>\n<p>  Since <code class=\"codespan\">dataZoomX</code> is defined before <code class=\"codespan\">dataZoomY</code>, <code class=\"codespan\">start: 30, end: 70</code> of <code class=\"codespan\">dataZoomX</code> means: from <code class=\"codespan\">30%</code> to <code class=\"codespan\">70%</code> out of full series.data, whereas <code class=\"codespan\">start: 20, end: 80</code> of <code class=\"codespan\">dataZoomY</code> means: from <code class=\"codespan\">20%</code> to <code class=\"codespan\">80%</code> out of the series.data having been filtered by <code class=\"codespan\">dataZoomX</code>.</p>\n<p>  If you want to change the process sequence, you can just change the sequence of the definitions apearing in <code class=\"codespan\">option</code>.</p>\n</li>\n</ul>\n</li>\n</ul>\n<p><br>\n<br></p>\n","properties":{}},"visualMap":{"type":"Array","items":{"anyOf":[{"type":["Object"],"description":"<p><strong>Continuous visualMap component (visualMapContinuous)</strong></p>\n<p> (See <a href=\"#visualMap\">the introduction to visual Map component (visualMap)</a>)</p>\n<p>You can set <a href=\"#visualMap.calculable\">visualMap.calculable</a> to show or hide the handles, which are used to change the selected range in <code class=\"codespan\">visualMapContinuous</code>.</p>\n<p><br>\n<br></p>\n","properties":{"type":{"type":["string"],"description":"<p>Used to determine that it is a continuous visualMap component.</p>\n","default":"continuous"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"min":{"type":["number"],"description":"\n\n<p>Specify the min dataValue for the visualMap component. <code class=\"codespan\">[visualMap.min, visualMax.max]</code> make up the domain of viusul mapping.</p>\n<p>Notice that <code class=\"codespan\">min</code> and <code class=\"codespan\">max</code> should be specified explicitly, and be <code class=\"codespan\">[0, 200]</code> by default, but not <code class=\"codespan\">dataMin</code> and <code class=\"codespan\">dataMax</code> in series.data.</p>\n","uiControl":{"type":"number"}},"max":{"type":["number"],"description":"\n\n<p>Specify the max dataValue for the visualMap component. <code class=\"codespan\">[visualMap.min, visualMax.max]</code> make up the domain of viusul mapping.</p>\n<p>Notice that <code class=\"codespan\">min</code> and <code class=\"codespan\">max</code> should be specified explicitly, and be <code class=\"codespan\">[0, 200]</code> by default, but not <code class=\"codespan\">dataMin</code> and <code class=\"codespan\">dataMax</code> in series.data.</p>\n","uiControl":{"type":"number"}},"range":{"type":["Array"],"description":"<p>Specify selected range, that is, the dataValue corresponding to the two handles. For example:</p>\n<pre><code class=\"lang-javascript\">chart.setOption({\n    visualMap: {\n        min: 0,\n        max: 100,\n        // dataValue corresponding to the two handles.\n        range: [4, 15],\n        ...\n    }\n});\n</code></pre>\n<p><strong>auto-adaption when min or max is modified by setOption</strong></p>\n<ul>\n<li>If <code class=\"codespan\">range</code> is not set (or set to null or undefined)</li>\n</ul>\n<pre><code class=\"lang-javascript\">For instance:\nchart.setOption({visualMap: {min: 10, max: 300}}); // range is not set, then range is [min, max] by default, that is, [10, 300].\n\nchart.setOption({visualMap: {min: 0, max: 400}}); // Modify min and max using setOption again.\n// Then range will be auto-modified to the new [min, max], that is, [0, 400].\n</code></pre>\n<ul>\n<li>If <code class=\"codespan\">range</code> is set explicitly, such as [10, 300]</li>\n</ul>\n<pre><code class=\"lang-javascript\">For instance:\nchart.setOption({visualMap: {min: 10, max: 300, range: [20, 80]}}); // range is set to [20, 80].\n\nchart.setOption({visualMap: {min: 0, max: 400}}); // min and max are modifies using setOption.\n// Then range keep the original value ([20, 80]) but will not do auto-adaption.\n\nchart.setOption({visualMap: {range: null}}); // Set range to null then.\n// Then auto-adaption of range turns on and range is auto modified to [min, max], that is, [0, 400].\n\n</code></pre>\n<p><code class=\"codespan\">range</code> gotten by <code class=\"codespan\">getOption</code> is always an <code class=\"codespan\">Array</code>, but not <code class=\"codespan\">null</code> or <code class=\"codespan\">undefined</code>.</p>\n"},"calculable":{"type":["boolean"],"description":"\n\n<p>Whether show handles, which can be dragged to adjust &quot;selected range&quot;.</p>\n<p>Notes: In order to be compatible with ECharts2, the rule, which seems to be a little odd, is retained: when <a href=\"#visualMap.type\">visualMap.type</a> is not set, and <a href=\"#visualMap-continuous.calculable\">visualMap.calculable</a> was set to be <code class=\"codespan\">true</code>, <a href=\"#visualMap.type\">visualMap.type</a> will be automatically set as <code class=\"codespan\">&#39;continuous&#39;</code>, regardless of some settings such as <a href=\"#visualMap-piecewise.splitNumber\">visualMap-piecewise.splitNumber</a>. Therefore, it is recommended to set <a href=\"#visualMap.type\">visualMap.type</a> explicitly, which avoids ambiguity.</p>\n","uiControl":{"type":"boolean"},"default":false},"realtime":{"type":["boolean"],"description":"\n\n<p>Whether to update view in real time when dragging a handle.</p>\n<ul>\n<li><p>If <code class=\"codespan\">ture</code>, the chart view will be updated in real time when dragging.</p>\n</li>\n<li><p>If <code class=\"codespan\">false</code>, the chart view will be updated at the end of the handle dragging.</p>\n</li>\n</ul>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"inverse":{"type":["boolean"],"description":"\n\n<p>Whether to inverse the layout of visualMap component.</p>\n<p>As <code class=\"codespan\">inverse</code> is <code class=\"codespan\">false</code>, the layout direction is the same as <a href=\"#grid\">cartesian coordinate</a>. That is:</p>\n<ul>\n<li>As <a href=\"#visualMap.orient\">visualMap.orient</a> is <code class=\"codespan\">&#39;vertical&#39;</code>, large data are placed at the top while small at the bottom.</li>\n<li>As <a href=\"#visualMap.orient\">visualMap.orient</a> is <code class=\"codespan\">&#39;horizontal&#39;</code>,  large data are placed on the right while small on the left.</li>\n</ul>\n<p>As <code class=\"codespan\">inverse</code> is <code class=\"codespan\">true</code>, the result is opposite.</p>\n","uiControl":{"type":"boolean"},"default":false},"precision":{"type":["number"],"description":"\n\n<p>The decimal precision of label, defaults to be 0 (no decimals).</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":0},"itemWidth":{"type":["number"],"description":"\n\n<p>The width of the main bar of visualMap component.</p>\n","uiControl":{"type":"number","default":"20","min":"0"},"default":20},"itemHeight":{"type":["number"],"description":"\n\n<p>The height of the main bar of visualMap component.</p>\n","uiControl":{"type":"number","default":"140","min":"0"},"default":140},"align":{"type":["string"],"description":"\n\n<p>Specify the position of handles and labels, against the main bar. The possible values are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;auto&#39;</code> Decide automatically.</li>\n<li><code class=\"codespan\">&#39;left&#39;</code> The handles and labels are on the right, which is valid when <code class=\"codespan\">orient</code> is set as <code class=\"codespan\">&#39;horizontal&#39;</code>.</li>\n<li><code class=\"codespan\">&#39;right&#39;</code> The handles and labels are on the left, which is valid when <code class=\"codespan\">orient</code> is set as <code class=\"codespan\">&#39;horizontal&#39;</code>.</li>\n<li><code class=\"codespan\">&#39;top&#39;</code> the handles and labels are at the bottom, which is valid when <code class=\"codespan\">orient</code> is set as  <code class=\"codespan\">&#39;vertical&#39;</code>.</li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code> the handles and labels are at the top, which is valid when <code class=\"codespan\">orient</code> is set as <code class=\"codespan\">&#39;vertical&#39;</code>.</li>\n</ul>\n","uiControl":{"type":"enum","options":"auto,left,right,top,bottom"},"default":"'auto'"},"text":{"type":["Array"],"description":"<p>The label text on both ends, such as <code class=\"codespan\">[&#39;High&#39;, &#39;Low&#39;]</code>. <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/map-visualMap-continuous-text&amp;edit=1&amp;reset=1\" target=\"_blank\">sample</a>.</p>\n<p>You can understand the order of items in <code class=\"codespan\">text</code> array just by a simple trial. See <a href=\"#visualMap.inverse\">visualMap.inverse</a>.</p>\n","default":null},"textGap":{"type":["number"],"description":"\n\n<p>The distance between the ends of the main bar and the label, with unit px. See <a href=\"#visualMap-continuous.text\">visualMap-continuous.text</a></p>\n","uiControl":{"type":"number","default":"10","step":"0.5"},"default":10},"show":{"type":["boolean"],"description":"<p>Whether to show visualMap-continuous component. If set as <code class=\"codespan\">false</code>, visualMap-continuous component will not show, but it can still perform visual mapping from dataValue to visual channel in chart.</p>\n","default":true},"dimension":{"type":["string"],"description":"<p>Specify which dimension should be used to fetch dataValue from <a href=\"#series.data\">series.data</a>, and then map them to visual channel.</p>\n<p><a href=\"#series.data\">series.data</a> can be regarded as a two-dimensional array, for instance:</p>\n<pre><code class=\"lang-javascript\">[\n    [12, 23, 43],\n    [12, 23, 43],\n    [43, 545, 65],\n    [92, 23, 33]\n]\n</code></pre>\n<p>Each column of the above array is regarded as a <code class=\"codespan\">dimension</code>. For example, when property <code class=\"codespan\">dimension</code> is set to 1, the second column (i.e., 23, 23, 545, 23) is chosen to perform visual mapping.</p>\n<p>Use the last dimension of <code class=\"codespan\">data</code> by default.</p>\n"},"seriesIndex":{"type":["number","Array"],"description":"<p>Specify visual mapping should be performed on which series, from which\n<a href=\"#series.data\">series.data</a> is fetched.</p>\n<p>All series are used by default.</p>\n"},"hoverLink":{"type":["boolean"],"description":"<p><code class=\"codespan\">hoverLink</code> enable highlight certain graphical elements of chart when mouse hovers on some place of <code class=\"codespan\">visualMap</code> component that is coresponding to those graphical elements by visual mapping.</p>\n<p>Inversely, when mouse hovers a graphical element of chart, its value label will be displayed on its corresponding position in <code class=\"codespan\">visualMap</code>.</p>\n","default":true},"inRange":{"type":["Object"],"description":"<p>Define visual channels that will mapped from dataValues that are <strong>in selected range</strong>. User can interact with visualMap component and make a seleced range by mouse or touch.</p>\n<ul>\n<li><code class=\"codespan\">symbol</code>: Type of symbol.</li>\n<li><code class=\"codespan\">symbolSize</code>: Symbol size.</li>\n<li><code class=\"codespan\">color</code>: Symbol color.</li>\n<li><code class=\"codespan\">colorAlpha</code>: Symbol alpha channel.</li>\n<li><code class=\"codespan\">opacity</code>: Opacity of symbol and others (like labels).</li>\n<li><code class=\"codespan\">colorLightness</code>: Lightness in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n<li><code class=\"codespan\">colorSaturation</code>: Saturation in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n<li><code class=\"codespan\">colorHue</code>: Hue in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n</ul>\n<p><code class=\"codespan\">inRange</code> could customize visual channels both in series (by <a href=\"#visualMap-continuous.seriesIndex\">visualMap-continuous.seriesIndex</a>) and in <code class=\"codespan\">visualMap-continuous</code> itself.</p>\n<p>For instance, if a <code class=\"codespan\">visualMap-continuous</code> component is used on a scatter chart, the mapping approach from data to <code class=\"codespan\">color</code> (or <code class=\"codespan\">symbol</code>, <code class=\"codespan\">size</code>, ...) can be both customized in the scatter chart and <code class=\"codespan\">visualMap-continuous</code> component itself. See the code as following:</p>\n<pre><code class=\"lang-javascript\">visualMap: [\n    {\n        ...,\n        // Define visual channels both in target series and visualMap-continuous component itself:\n        inRange: {\n            color: [&#39;#121122&#39;, &#39;rgba(3,4,5,0.4)&#39;, &#39;red&#39;],\n            symbolSize: [30, 100]\n        }\n    }\n]\n</code></pre>\n<p>If you want to define visual channels for target series and visualMap-continuous component separately, you should do as follows:</p>\n<pre><code class=\"lang-javascript\">visualMap: [\n    {\n        ...,\n        // Define visual channels only for target series.\n        target: {\n            inRange: {\n                color: [&#39;#121122&#39;, &#39;rgba(3,4,5,0.4)&#39;, &#39;red&#39;],\n                symbolSize: [60, 200]\n            }\n        },\n        // Define visual channels only for visualMap-continuous component.\n        controller: {\n            inRange: {\n                symbolSize: [30, 100]\n            }\n        }\n    }\n]\n</code></pre>\n<p>Or define as follows:</p>\n<pre><code class=\"lang-javascript\">visualMap: [\n    {\n        ...,\n        // Define visual channels for both target series and visualMap-continuous component.\n        inRange: {\n            color: [&#39;#121122&#39;, &#39;rgba(3,4,5,0.4)&#39;, &#39;red&#39;],\n            symbolSize: [60, 200]\n        },\n        // Define visual channels only for visualMap-continuous component, which\n        // will overlap the properties with the same name in the above common\n        // definition. (symbolSize is overlapped by [30, 100] while color\n        // keeps the original value)\n        controller: {\n            inRange: {\n                symbolSize: [30, 100]\n            }\n        }\n    }\n]\n</code></pre>\n<p><br></p>\n<hr>\n<p><strong>✦ About visual channels ✦</strong></p>\n<ul>\n<li><p>Various visual channels (such as <code class=\"codespan\">color</code>、<code class=\"codespan\">symbolSize</code> and ect.) can be defined in inRange at the same time and all of them will be apopted.</p>\n</li>\n<li><p>Basically visual channels <code class=\"codespan\">opacity</code> is recommended, rather than <code class=\"codespan\">colorAlpha</code>. The former controls the transparency of both graphical element and its attachments (like label), whereas the latter only controls the transparency of graphical element.</p>\n</li>\n<li><p>There are two approaches of visual mapping supported: &#39;Linear Mapping&#39; and &#39;Table Mapping&#39;.</p>\n</li>\n</ul>\n<p><br></p>\n<hr>\n<p><strong>✦ Linear Mapping to visual channel ✦</strong></p>\n<p><code class=\"codespan\">Linear Mapping</code> means that linear calculation will be performed on each dataValue (value of series.data), mapping them from the domain of <code class=\"codespan\">[visaulMap.min, visualMap.max]</code> to a given range of <code class=\"codespan\">[visual value 1, visual value 2]</code> and obtaining a final value (say visual value) for visual channel rendering.</p>\n<p>For instance, <code class=\"codespan\">[visualMap.min, visualMap.max]</code> is set to be <code class=\"codespan\">[0, 100]</code>, and there is series.data: <code class=\"codespan\">[50, 10, 100]</code>. We intend to map them to an <code class=\"codespan\">opacity</code> range <code class=\"codespan\">[0.4, 1]</code>, by which the size of value can be demostrated by the transparency of graphical elements. visualMap component will then linear calculate them and get opacity values <code class=\"codespan\">[0.7, 0.44, 1]</code>, cooresponding to each dataValue.</p>\n<p>We can also set the visual range inversely, such as <code class=\"codespan\">opacity: [1, 0.4]</code>, and the final mapping result for the given series.data above will be <code class=\"codespan\">[0.7, 0.96, 0.4]</code>.</p>\n<p>Notice: [visualMap.min, visualMap.max] should be set manually and is [0, 100] by default, but not <code class=\"codespan\">dataMin</code> and <code class=\"codespan\">dataMax</code> in series.data.</p>\n<p>How to configure visualMap component to do Linear Mapping?</p>\n<ul>\n<li><p>When use <a href=\"#visualMap-continuous\">visualMap-continuous</a>, or</p>\n</li>\n<li><p>When use <a href=\"#visualMap-piecewise\">visualMap-piecewise</a> and <a href=\"#visualMap-piecewise.categories\">visualMap-piecewise.categories</a> is not used.</p>\n</li>\n</ul>\n<p>About the value of visual channel (visual value):</p>\n<ul>\n<li><p>Basically <code class=\"codespan\">Array</code> is used to express the range of visual value, e.g., <code class=\"codespan\">color: [&#39;#333&#39;, &#39;#777&#39;]</code>.</p>\n</li>\n<li><p>Single <code class=\"codespan\">number</code> or single <code class=\"codespan\">string</code> can also be used, which will be converted to an <code class=\"codespan\">Array</code> by visualMap component. e.g.:  <code class=\"codespan\">opacity: 0.4</code> will be converted to <code class=\"codespan\">opacity: [0.4, 0.4]</code>, <code class=\"codespan\">color: &#39;#333&#39;</code> will be converted to <code class=\"codespan\">color: [&#39;#333&#39;, &#39;#333&#39;]</code>.</p>\n</li>\n<li><p>For visual channel <code class=\"codespan\">symbolSize</code>, <code class=\"codespan\">opacity</code>, <code class=\"codespan\">colorAlpha</code>, <code class=\"codespan\">colorLightness</code>, <code class=\"codespan\">colorSaturation</code>, <code class=\"codespan\">colorHue</code>, the range of visual value is always in the form of: <code class=\"codespan\">[visual value of visualMap.min, visual value of visualMap.max]</code>. For example, <code class=\"codespan\">colorLightness: [0.8, 0.2]</code> means that the dataValue in series.data that equals to <code class=\"codespan\">visualMap.min</code> (if any) will be mapped to lightness <code class=\"codespan\">0.8</code>, and the dataValue that equals to <code class=\"codespan\">visualMap.max</code> (if any) will be mapped to lightness <code class=\"codespan\">0.2</code>, and other dataValues will be mapped by the linear calculateion based on the domain of <code class=\"codespan\">[visualMap.min, visualMap.max]</code> and the range of <code class=\"codespan\">[0.8, 0.2]</code>.</p>\n</li>\n<li><p>For visual channel <code class=\"codespan\">color</code>, array is used, like: <code class=\"codespan\">[&#39;#333&#39;, &#39;#78ab23&#39;, &#39;blue&#39;]</code>, which means a color ribbon is formed based on the three color stops, and dataValues will be mapped to the ribbon. Specifically, the dataValue that equals to <code class=\"codespan\">visualMap.min</code> will be mapped onto <code class=\"codespan\">&#39;#333&#39;</code>, the dataValue that equals to <code class=\"codespan\">visualMap.max</code> will be mapped onto <code class=\"codespan\">&#39;blue&#39;</code>, and other dataValues will be piecewisely interpolated to get the final color.</p>\n</li>\n<li><p>For visual channel <code class=\"codespan\">symbol</code>, array is used, like: <code class=\"codespan\">[&#39;circle&#39;, &#39;rect&#39;, &#39;diamond&#39;]</code>, where the dataValue that equals to <code class=\"codespan\">visualMap.min</code> will be mapped onto <code class=\"codespan\">&#39;circle&#39;</code>, the dataValue that equals to <code class=\"codespan\">visualMap.max</code> will be mapped onto <code class=\"codespan\">&#39;diamond&#39;</code>, and other dataValues will be caculated based on the numerical distance to <code class=\"codespan\">visualMax.min</code> and to <code class=\"codespan\">visualMap.max</code>, and mapped onto one of <code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>.</p>\n</li>\n</ul>\n<p>About the possible value range of visual value:</p>\n<ul>\n<li><p><code class=\"codespan\">opacity</code>、<code class=\"codespan\">colorAlpha</code>、<code class=\"codespan\">colorLightness</code>、<code class=\"codespan\">colorSaturation</code>、<code class=\"codespan\">visual value</code></p>\n<p>  possible value range is <code class=\"codespan\">[0, 1]</code>.</p>\n</li>\n<li><p><code class=\"codespan\">colorHue</code>：</p>\n<p>  possible value range is <code class=\"codespan\">[0, 360]</code>.</p>\n</li>\n<li><p><code class=\"codespan\">color</code>：</p>\n<p>  color can use RGB expression, like <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>, or RGBA expression, like <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>, or Hex expression, like &#39;#ccc&#39;.</p>\n</li>\n<li><p><code class=\"codespan\">symbol</code>：</p>\n</li>\n</ul>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p><br></p>\n<hr>\n<p><strong>✦ Table Mapping to visual channel ✦</strong></p>\n<p><code class=\"codespan\">Table Mapping</code> could be used when dataValue (values in series.data, specified by <a href=\"#visualMap.dimension\">visualMap.dimension</a>) is enumerable and we intend to map them to visual value by looking up a given table.</p>\n<p>For instance, in a <a href=\"#visualMap-piecewise\">visualMap-piecewise</a> component, <a href=\"#visualMap-piecewise.categories\">visualMap-piecewise.categories</a> is set to <code class=\"codespan\">[&#39;Demon Hunter&#39;, &#39;Blademaster&#39;, &#39;Death Knight&#39;, &#39;Warden&#39;, &#39;Paladin&#39;]</code>. And there is series.data: <code class=\"codespan\">[&#39;Demon Hunter&#39;, &#39;Death Knight&#39;, &#39;Warden&#39;, &#39;Paladin&#39;]</code>. Then we can establish the lookup rule for color: <code class=\"codespan\">color: {&#39;Warden&#39;: &#39;red&#39;, &#39;Demon Hunter&#39;: &#39;black&#39;}</code>, by which the <code class=\"codespan\">visualMap</code> component will map <code class=\"codespan\">dataValue</code> to <code class=\"codespan\">color</code>.</p>\n<p>How to configure <code class=\"codespan\">visualMap</code> component to do <code class=\"codespan\">Table Mapping</code>?</p>\n<p>When use <a href=\"#visualMap-piecewise\">visualMap-piecewise</a> and <a href=\"#visualMap-piecewise.categories\">visualMap-piecewise.categories</a>is set.</p>\n<p>About the value of visual channel (visual value):</p>\n<p>Generally <code class=\"codespan\">Object</code> or <code class=\"codespan\">Array</code> is used, for instance:</p>\n<pre><code class=\"lang-javascript\">visualMap: {\n    type: &#39;piecewise&#39;,\n    // categories defines the items that to be displayed in visualMap-piecewise component.\n    categories: [\n        &#39;Demon Hunter&#39;, &#39;Blademaster&#39;, &#39;Death Knight&#39;, &#39;Warden&#39;, &#39;Paladin&#39;\n    ],\n    inRange: {\n        // visual value can be an Object：\n        color: {\n            &#39;Warden&#39;: &#39;red&#39;,\n            &#39;Demon Hunter&#39;: &#39;black&#39;,\n            &#39;&#39;: &#39;green&#39; // Blank string means that except &#39;Warden&#39; and &#39;Demon Hunter&#39;,\n                        // all other dataValues should be mapped to &#39;green&#39;.\n        }\n        // visual value can also be a single value,\n        // means that all dataValues should be mapped to the value.\n        color: &#39;green&#39;,\n        // visual value can also be a array, with the same length\n        // as the array of categories and one-one mapping onto it.\n        color: [&#39;red&#39;, &#39;black&#39;, &#39;green&#39;, &#39;yellow&#39;, &#39;white&#39;]\n    }\n}\n</code></pre>\n<p><a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/scatter-visualMap-categories&amp;edit=1&amp;reset=1\" target=\"_blank\">Example</a></p>\n<p><strong>✦ How to modity configurations of vsiual encoding? ✦</strong></p>\n<p>If you want to modify the configurations of visual encoding after chart been rendered (by invoke <code class=\"codespan\">setOption</code> to set the initial <code class=\"codespan\">option</code>), <code class=\"codespan\">setOption</code> can be used again to modify configurations of visual encoding. For instance:</p>\n<pre><code class=\"lang-javascript\">chart.setOption({\n    visualMap: {\n        inRange: {color: [&#39;red&#39;, &#39;blue&#39;]}\n    }\n});\n</code></pre>\n<p>Notice:</p>\n<ul>\n<li><p>These visualMap properties (i.e. <code class=\"codespan\">inRange</code>, <code class=\"codespan\">outOfRange</code>, <code class=\"codespan\">target</code>, <code class=\"codespan\">controller</code>) do not support &quot;merge&quot;, that is, anyone among them is modified when use <code class=\"codespan\">setOption</code> again, all of the original values of them will not be kept but erased. The &quot;merge&quot; brings complication in implemnentation and understanding, whereas &quot;erase all&quot; normalize the practise: once you want to modify some visual values, you should pass all of them to <code class=\"codespan\">setOption</code>, no matter they are to be changed.</p>\n</li>\n<li><p>This way, <code class=\"codespan\">getOption() -&gt; modify the gotten option -&gt; setOption(modified option)</code>, is strongly <strong>not recommended</strong>, for instance:</p>\n</li>\n</ul>\n<pre><code class=\"lang-javascript\">// Not recommended approach, regardless of its correctness:\n\nvar option = chart.getOption(); // Get the entire option.\noption.visualMap.inRange.color = [&#39;red&#39;, &#39;blue&#39;]; // modify color, which is what you want.\n\n// You have to modify those two properties, otherwise you will not get what you want.\noption.visualMap.target.inRange.color = [&#39;red&#39;, &#39;blue&#39;];\noption.visualMap.controller.inRange.color = [&#39;red&#39;, &#39;blue&#39;];\n\nchart.setOption(option); // set the modified option back.\n// You should not use this approach, but use the\n// approach demostrated before this example.\n</code></pre>\n<p><strong>Notice:</strong> There is default color <code class=\"codespan\">[&#39;#f6efa6&#39;, &#39;#d88273&#39;, &#39;#bf444c&#39;]</code> in <code class=\"codespan\">inRange</code> if you not set <code class=\"codespan\">inRange</code>. If you dont want it, set <code class=\"codespan\">inRange: {color: null}</code> to disable it.</p>\n"},"outOfRange":{"type":["Object"],"description":"<p>Define visual channels that will mapped from dataValues that are <strong>out of selected range</strong>. User can interact with visualMap component and make a seleced range by mouse or touch.</p>\n<p>See available configurations in <a href=\"#visualMap-continuous.inRange\">visualMap-continuous.inRange</a></p>\n"},"controller":{"type":["Object"],"description":"<p>Property <code class=\"codespan\">inRange</code> and <code class=\"codespan\">outOfRange</code> can be set within property <code class=\"codespan\">controller</code>, which means those <code class=\"codespan\">inRange</code> and <code class=\"codespan\">outOfRange</code> are only used on the controller (<code class=\"codespan\">visualMap</code> component itself), but are not used on chart (series). This property is useful in some scenarios when the view of controller needs to be customized in detail.</p>\n","properties":{"inRange":{"type":["Object"],"description":"<p>Define visual channels that will mapped from dataValues that are <strong>in selected range</strong>. User can interact with visualMap component and make a seleced range by mouse or touch.</p>\n<p>See available configurations in <a href=\"#visualMap-continuous.inRange\">visualMap-continuous.inRange</a></p>\n"},"outOfRange":{"type":["Object"],"description":"<p>Define visual channels that will mapped from dataValues that are <strong>out of selected range</strong>. User can interact with visualMap component and make a seleced range by mouse or touch.</p>\n<p>See available configurations in <a href=\"#visualMap-continuous.inRange\">visualMap-continuous.inRange</a></p>\n"}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":4},"left":{"type":["string","number"],"description":"<p>Distance between visualMap  component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":0},"top":{"type":["string","number"],"description":"<p>Distance between visualMap  component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"auto"},"right":{"type":["string","number"],"description":"<p>Distance between visualMap  component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":"auto"},"bottom":{"type":["string","number"],"description":"<p>Distance between visualMap  component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":0},"orient":{"type":["string"],"description":"<p>How to layout the visualMap component, <code class=\"codespan\">&#39;horizontal&#39;</code> or <code class=\"codespan\">&#39;vertical&#39;</code>.</p>\n","default":"'vertical'"},"padding":{"type":["number","Array"],"description":"\n\n<p>visualMap-continuous space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"backgroundColor":{"type":["Color"],"description":"<p>background color of visualMap component.</p>\n","default":"'rgba(0,0,0,0)'"},"borderColor":{"type":["Color"],"description":"<p>border color of visualMap component.</p>\n","default":"'#ccc'"},"borderWidth":{"type":["number"],"description":"<p>border width of visualMap component, with unit: px.</p>\n","default":0},"color":{"type":["Array"],"description":"<p>This property remains only for compatibility with ECharts2, and is not recommended in ECharts3. It is recommended to configure color in <a href=\"#visualMap-continuous.inRange\">visualMap-continuous.inRange</a>, or <a href=\"#visualMap-continuous.outOfRange\">visualMap-continuous.outOfRange</a> if needed.</p>\n<p>If you persist in using it, the following issue should be noticed: the sequence of dataValues that are mapped to colorValues in property <code class=\"codespan\">color</code> is from <code class=\"codespan\">large</code> to <code class=\"codespan\">small</code>, whereas that in <a href=\"#visualMap-continuous.inRange\">visualMap-continuous.inRange</a> or <a href=\"#visualMap-continuous.outOfRange\">visualMap-continuous.outOfRange</a> is from <code class=\"codespan\">small</code> to <code class=\"codespan\">large</code>.</p>\n","default":"['#bf444c', '#d88273', '#f6efa6']"},"textStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>visualMap  text color.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"#333"},"fontStyle":{"type":["string"],"description":"\n\n<p>visualMap  font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p>visualMap  font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p>visualMap  font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p>visualMap  font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"formatter":{"type":["string","Function"],"description":"<p>the formatter tool for label.</p>\n<ul>\n<li><p>If it was set as a <code class=\"codespan\">string</code>, it refers to a template, for instance: <code class=\"codespan\">aaaa{value}bbbb</code>, where <code class=\"codespan\">{value}</code> represents the value of the edge of the seleted range.</p>\n</li>\n<li><p>If it was set as a <code class=\"codespan\">Function</code>, it refers to a callback function, for instance:</p>\n</li>\n</ul>\n<pre><code class=\"lang-javascript\">formatter: function (value) {\n    return &#39;aaaa&#39; + value + &#39;bbbb&#39;;\n}\n</code></pre>\n"},"handleIcon":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Icon of drag handle.</p>\n<pre><code class=\"lang-js\">&#39;M-11.39,9.77h0a3.5,3.5,0,0,1-3.5,3.5h-22a3.5,3.5,0,0,1-3.5-3.5h0a3.5,3.5,0,0,1,3.5-3.5h22A3.5,3.5,0,0,1-11.39,9.77Z&#39;\n</code></pre>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon"}},"handleSize":{"type":["number","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Size of drag handle. It can be a percent string.</p>\n","default":"'120%'"},"handleStyle":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Style of drag handle.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"#fff"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"indicatorIcon":{"type":["string"],"description":"<p>Icon of indicator.</p>\n<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n","uiControl":{"type":"icon"},"default":"'circle'"},"indicatorSize":{"type":["number","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Size of indicator. It can be a percent string.</p>\n","default":"'50%'"},"indicatorStyle":{"type":["Object"],"description":"<p>Style of indicator.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"#fff"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"2","min":"0","step":"0.5"},"default":2},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"2","min":"0","step":"0.5"},"default":2},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"rgba(0,0,0,0.2)"},"default":"rgba(0,0,0,0.2)"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"1","step":"0.5"},"default":1},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"1","step":"0.5"},"default":1},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},{"type":["Object"],"description":"<p><strong>Piecewise visualMap component (visualMapPiecewise) </strong></p>\n<p> (Reference to <a href=\"#visualMap\">the introduction of visual Map component (visualMap)</a>)</p>\n<p>Sample:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/scatter-visualMap-piecewise&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n\n<p>Piecewise visualMap component works in one of the three modes:</p>\n<ul>\n<li><strong>CONTINUOUS-AVERAGE</strong>: The series.data is continuous and is divided into pieces averagely according to <a href=\"#visualMap-piecewise.splitNumber\">visualMap-piecewise.splitNumber</a>.</li>\n<li><strong>CONTINUOUS-CUSTOMIZED</strong>: The series.data is continuous and is divided into pieces according to the given rule defined in <a href=\"#visualMap-piecewise.pieces\">visualMap-piecewise.pieces</a>.</li>\n<li><strong>CATEGORY</strong>: The series.data is discrete and is categorized according to <a href=\"#visualMap-piecewise.categories\">visualMap-piecewise.categories</a>.</li>\n</ul>\n<p><br>\n<br></p>\n","properties":{"type":{"type":["string"],"description":"<p>Used to determine it is a piecewise visualMap component.</p>\n","default":"piecewise"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"splitNumber":{"type":["number"],"description":"\n\n<p>Continuous data can be divide into pieces averagely according to splitNumber, that is, if splitNumber is 5, data will be sliced into 5 pieces.</p>\n<p>The range of continuous data should be defined by <a href=\"#visualMap-piecewise.max\">max</a> and <a href=\"#visualMap-piecewise.min\">min</a>.</p>\n<p>If <a href=\"#visualMap-piecewise.pieces\">visualMap-piecewise.pieces</a> or <a href=\"#visualMap-piecewise.categories\">visualMap-piecewise.categories</a> is set up, the <code class=\"codespan\">splitNumber</code> will not be used any more.</p>\n","uiControl":{"type":"number","default":"5","min":"1","step":"1"},"default":5},"pieces":{"type":["Array"],"description":"<p>Used to customize how to slice continuous data, and some specific view style for some pieces. For instance:</p>\n<pre><code class=\"lang-javascript\">pieces: [\n    // Range of a piece can be specified by property min and max,\n    // where min will be set as -Infinity if ignored,\n    // and max will be set as Infinity if ignored.\n    {min: 1500},\n    {min: 900, max: 1500},\n    {min: 310, max: 1000},\n    {min: 200, max: 300},\n    // Label of the piece can be specified.\n    {min: 10, max: 200, label: &#39;10 to 200 (custom label) &#39;},\n    // Color of the piece can be specified.\n    {value: 123, label: &#39;123 (custom special color) &#39;, color: &#39;grey&#39;},\n    {max: 5}\n]\n</code></pre>\n<p>These visual channel can be customized in each piece:</p>\n<ul>\n<li><code class=\"codespan\">symbol</code>: Type of symbol.</li>\n<li><code class=\"codespan\">symbolSize</code>: Symbol size.</li>\n<li><code class=\"codespan\">color</code>: Symbol color.</li>\n<li><code class=\"codespan\">colorAlpha</code>: Symbol alpha channel.</li>\n<li><code class=\"codespan\">opacity</code>: Opacity of symbol and others (like labels).</li>\n<li><code class=\"codespan\">colorLightness</code>: Lightness in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n<li><code class=\"codespan\">colorSaturation</code>: Saturation in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n<li><code class=\"codespan\">colorHue</code>: Hue in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n</ul>\n<p> (Notes: In ECharts2, <code class=\"codespan\">pieces</code> is called <code class=\"codespan\">splitList</code>, which is retained in ECharts3 for compatibility. But <code class=\"codespan\">pieces</code> is recommended.)</p>\n<p>You would realize the sequence in <code class=\"codespan\">pieces</code> by a simple trial. See more detailed rules in <a href=\"#visualMap.inverse\">visualMap.inverse</a>.</p>\n"},"categories":{"type":["Array"],"description":"<p>When dataValues in series.data (specified by <a href=\"#visualMap-piecewise.dimension\">visualMap-piecewise.dimension</a>) are discrete (or also known as category data or enumerable data), and we intend to perform <strong>Table Mapping</strong> from dataValue to visual channels, <code class=\"codespan\">categories</code> is used to describe the entire enumeration of data. For instance:</p>\n<pre><code class=\"lang-javascript\">categories: [\n    &#39;Demon Hunter&#39;, &#39;Blademaster&#39;, &#39;Death Knight&#39;, &#39;Warden&#39;, &#39;Paladin&#39;\n],\n</code></pre>\n<p><a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/scatter-visualMap-categories&amp;edit=1&amp;reset=1\" target=\"_blank\">Sample</a></p>\n<p>You would realize the sequence in <code class=\"codespan\">categories</code> by a simple trial. See more detailed rules in <a href=\"#visualMap.inverse\">visualMap.inverse</a>.</p>\n"},"min":{"type":["number"],"description":"\n\n<p>Specify the min dataValue for the visualMap component. <code class=\"codespan\">[visualMap.min, visualMax.max]</code> make up the domain of viusul mapping.</p>\n<p>In <strong>CONTINUOUS-CUSTOMIZED</strong> mode (i.e., <a href=\"#visualMap-piecewise.pieces\">visualMap-piecewise.pieces</a> is used) or <strong>CATEGORY</strong> mode (i.e., <a href=\"#visualMap-piecewise.categories\">visualMap-piecewise.categories</a> is used), <code class=\"codespan\">max</code> and <code class=\"codespan\">min</code> doesn&#39;t need to be specified.</p>\n<p>In <strong>CONTINUOUS-AVERAGE</strong> mode (i.e., <a href=\"#visualMap-piecewise.splitNumber\">visualMap-piecewise.splitNumber</a> is used), they should be specified explicitly, and be <code class=\"codespan\">[0, 200]</code> by default, but not <code class=\"codespan\">dataMin</code> and <code class=\"codespan\">dataMax</code> in series.data.</p>\n","uiControl":{"type":"number"}},"max":{"type":["number"],"description":"\n\n<p>Specify the max dataValue for the visualMap component. <code class=\"codespan\">[visualMap.min, visualMax.max]</code> make up the domain of viusul mapping.</p>\n<p>In <strong>CONTINUOUS-CUSTOMIZED</strong> mode (i.e., <a href=\"#visualMap-piecewise.pieces\">visualMap-piecewise.pieces</a> is used) or <strong>CATEGORY</strong> mode (i.e., <a href=\"#visualMap-piecewise.categories\">visualMap-piecewise.categories</a> is used), <code class=\"codespan\">max</code> and <code class=\"codespan\">min</code> doesn&#39;t need to be specified.</p>\n<p>In <strong>CONTINUOUS-AVERAGE</strong> mode (i.e., <a href=\"#visualMap-piecewise.splitNumber\">visualMap-piecewise.splitNumber</a> is used), they should be specified explicitly, and be <code class=\"codespan\">[0, 200]</code> by default, but not <code class=\"codespan\">dataMin</code> and <code class=\"codespan\">dataMax</code> in series.data.</p>\n","uiControl":{"type":"number"}},"minOpen":{"type":["boolean"],"description":"\n\n<p>This option works when <code class=\"codespan\">type</code> is <code class=\"codespan\">piecewise</code> and <code class=\"codespan\">min</code>/<code class=\"codespan\">max</code>/<code class=\"codespan\">splitNumber</code> are set.</p>\n<p>If it is set as <code class=\"codespan\">true</code>, an extra piece labeled with &quot;&lt; min&quot; will show.</p>\n","uiControl":{"type":"boolean"}},"maxOpen":{"type":["boolean"],"description":"\n\n<p>This option works when <code class=\"codespan\">type</code> is <code class=\"codespan\">piecewise</code> and <code class=\"codespan\">min</code>/<code class=\"codespan\">max</code>/<code class=\"codespan\">splitNumber</code> are set.</p>\n<p>If it is set as <code class=\"codespan\">true</code>, an extra piece labeled with &quot;&gt; max&quot; will show.</p>\n","uiControl":{"type":"boolean"}},"selectedMode":{"type":["string"],"description":"\n\n<p>Selected Mode could be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;multiple&#39;</code> (multiple selection).</li>\n<li><code class=\"codespan\">&#39;single&#39;</code> (single selection).</li>\n</ul>\n","uiControl":{"type":"enum","options":"single,multiple"},"default":"'multiple'"},"inverse":{"type":["boolean"],"description":"\n\n<p>Whether to inverse the layout of visualMap component.</p>\n<ul>\n<li><p>In <strong>CONTINUOUS-AVERAGE</strong> mode (i.e., <a href=\"#visualMap-piecewise.splitNumber\">visualMap-piecewise.splitNumber</a> is used), the rule of data layout is the same as <a href=\"#visualMap-continuous.inverse\">visualMap-continuous.inverse</a>.</p>\n</li>\n<li><p>In <strong>CONTINUOUS-CUSTOMIZED</strong> mode (i.e., <a href=\"#visualMap-piecewise.pieces\">visualMap-piecewise.pieces</a> is used) or <strong>CATEGORY</strong> mode (i.e., <a href=\"#visualMap-piecewise.categories\">visualMap-piecewise.categories</a> is used), the layout of each piece is determined by the their order in the definition of <code class=\"codespan\">pieces</code> or <code class=\"codespan\">categories</code>, namely:</p>\n<ul>\n<li><p>When <code class=\"codespan\">inverse</code> is <code class=\"codespan\">false</code>:</p>\n<ul>\n<li><p>When <a href=\"#visualMap.orient\">visualMap.orient</a> is <code class=\"codespan\">&#39;vertical&#39;</code>, pieces[0] or categories[0] correspond to upward side.</p>\n</li>\n<li><p>When <a href=\"#visualMap.orient\">visualMap.orient</a> is <code class=\"codespan\">&#39;horizontal&#39;</code>, pieces[0] or categories[0] correspond to left side.</p>\n</li>\n</ul>\n</li>\n<li><p>When <code class=\"codespan\">inverse</code> is <code class=\"codespan\">true</code>, the results are opposite to above.</p>\n</li>\n</ul>\n</li>\n</ul>\n<p>If you just have a try, you&#39;ll know it is not so complicated.</p>\n","uiControl":{"type":"boolean"},"default":false},"precision":{"type":["number"],"description":"\n\n<p>The decimal precision of label, defaults to be 0 (no decimals).</p>\n<ul>\n<li><p>In <strong>CONTINUOUS-AVERAGE</strong> mode (i.e., <a href=\"#visualMap-piecewise.splitNumber\">visualMap-piecewise.splitNumber</a> is used), the rule of data layout is the same as <a href=\"#visualMap-continuous.inverse\">visualMap-continuous.inverse</a>, decimal percision auto adapts to series.data.</p>\n</li>\n<li><p>In <strong>CONTINUOUS-CUSTOMIZED</strong> mode (i.e., <a href=\"#visualMap-piecewise.pieces\">visualMap-piecewise.pieces</a> is used) or <strong>CATEGORY</strong> mode (i.e., <a href=\"#visualMap-piecewise.categories\">visualMap-piecewise.categories</a> is used), decimal percision defaults to be 0 (no decimals):</p>\n</li>\n</ul>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":null},"itemWidth":{"type":["number"],"description":"\n\n<p>The width of each graphical element that represents a piece.</p>\n","uiControl":{"type":"number","default":"20","min":"0"},"default":20},"itemHeight":{"type":["number"],"description":"\n\n<p>The height of each graphical element that represents a piece.</p>\n","uiControl":{"type":"number","default":"14","min":"0"},"default":14},"align":{"type":["string"],"description":"\n\n<p>The layout relationship between the graphical elements for pieces and their labels. Possible values are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;auto&#39;</code> Decide automatically.</li>\n<li><code class=\"codespan\">&#39;left&#39;</code> The graphical elements for pieces are on the left and their labels are on the right.</li>\n<li><code class=\"codespan\">&#39;right&#39;</code> The graphical elements for pieces are on the right and their labels are on the left.</li>\n</ul>\n","uiControl":{"type":"enum","options":"auto,left,right"},"default":"'auto'"},"text":{"type":["Array"],"description":"<p>The label text on both ends, such as <code class=\"codespan\">[&#39;High&#39;, &#39;Low&#39;]</code>. <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/map-visualMap-piecewise-text&amp;edit=1&amp;reset=1\" target=\"_blank\">Sample</a>.</p>\n<p>You can understand the order of items in <code class=\"codespan\">text</code> array just by a simple trial. See <a href=\"#visualMap.inverse\">visualMap.inverse</a>.</p>\n<p>The rule, that labels will not show when <code class=\"codespan\">text</code> is use, is retained for compatibility with ECharts2.</p>\n","default":null},"textGap":{"type":["number"],"description":"\n\n<p>The distance between the ends of the graphical elements for pieces and the labels, with unit px. See <a href=\"#visualMap-piecewise.text\">visualMap-piecewise.text</a></p>\n","uiControl":{"type":"number","default":"10"},"default":10},"showLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show label of each item. By default, label will not be shown when <a href=\"#visualMap-piecewise.text\">visualMap-piecewise.text</a> used, otherwise label will be shown.</p>\n","uiControl":{"type":"boolean"}},"itemGap":{"type":["*"],"description":"\n\n<p>Its the distance between each two graphical elements for pieces. The unit is px.</p>\n","uiControl":{"type":"number","default":"10"},"default":10},"itemSymbol":{"type":["string"],"description":"<p>Default symbol (the shape of graphical element). Possible values are:</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>The setting of visual channel <code class=\"codespan\">symbol</code> can refer to <a href=\"#visualMap-piecewise.inRange\">visualMap-piecewise.inRange</a> and <a href=\"#visualMap-piecewise.outOfRange\">visualMap-piecewise.outOfRange</a>.</p>\n<p>When they are not specified, <code class=\"codespan\">itemSymbol</code> is adopted as the default value (but just used in visualMap component itself, not in chart).</p>\n","default":"'roundRect'"},"show":{"type":["boolean"],"description":"<p>Whether to show visualMap-piecewise component. If set as <code class=\"codespan\">false</code>, visualMap-piecewise component will not show, but it can still perform visual mapping from dataValue to visual channel in chart.</p>\n","default":true},"dimension":{"type":["string"],"description":"<p>Specify which dimension should be used to fetch dataValue from <a href=\"#series.data\">series.data</a>, and then map them to visual channel.</p>\n<p><a href=\"#series.data\">series.data</a> can be regarded as a two-dimensional array, for instance:</p>\n<pre><code class=\"lang-javascript\">[\n    [12, 23, 43],\n    [12, 23, 43],\n    [43, 545, 65],\n    [92, 23, 33]\n]\n</code></pre>\n<p>Each column of the above array is regarded as a <code class=\"codespan\">dimension</code>. For example, when property <code class=\"codespan\">dimension</code> is set to 1, the second column (i.e., 23, 23, 545, 23) is chosen to perform visual mapping.</p>\n<p>Use the last dimension of <code class=\"codespan\">data</code> by default.</p>\n"},"seriesIndex":{"type":["number","Array"],"description":"<p>Specify visual mapping should be performed on which series, from which\n<a href=\"#series.data\">series.data</a> is fetched.</p>\n<p>All series are used by default.</p>\n"},"hoverLink":{"type":["boolean"],"description":"<p><code class=\"codespan\">hoverLink</code> enable highlight certain graphical elements of chart when mouse hovers on some place of <code class=\"codespan\">visualMap</code> component that is coresponding to those graphical elements by visual mapping.</p>\n<p>Inversely, when mouse hovers a graphical element of chart, its value label will be displayed on its corresponding position in <code class=\"codespan\">visualMap</code>.</p>\n","default":true},"inRange":{"type":["Object"],"description":"<p>Define visual channels that will mapped from dataValues that are <strong>in selected range</strong>. User can interact with visualMap component and make a seleced range by mouse or touch.</p>\n<ul>\n<li><code class=\"codespan\">symbol</code>: Type of symbol.</li>\n<li><code class=\"codespan\">symbolSize</code>: Symbol size.</li>\n<li><code class=\"codespan\">color</code>: Symbol color.</li>\n<li><code class=\"codespan\">colorAlpha</code>: Symbol alpha channel.</li>\n<li><code class=\"codespan\">opacity</code>: Opacity of symbol and others (like labels).</li>\n<li><code class=\"codespan\">colorLightness</code>: Lightness in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n<li><code class=\"codespan\">colorSaturation</code>: Saturation in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n<li><code class=\"codespan\">colorHue</code>: Hue in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n</ul>\n<p><code class=\"codespan\">inRange</code> could customize visual channels both in series (by <a href=\"#visualMap-piecewise.seriesIndex\">visualMap-piecewise.seriesIndex</a>) and in <code class=\"codespan\">visualMap-piecewise</code> itself.</p>\n<p>For instance, if a <code class=\"codespan\">visualMap-piecewise</code> component is used on a scatter chart, the mapping approach from data to <code class=\"codespan\">color</code> (or <code class=\"codespan\">symbol</code>, <code class=\"codespan\">size</code>, ...) can be both customized in the scatter chart and <code class=\"codespan\">visualMap-piecewise</code> component itself. See the code as following:</p>\n<pre><code class=\"lang-javascript\">visualMap: [\n    {\n        ...,\n        // Define visual channels both in target series and visualMap-piecewise component itself:\n        inRange: {\n            color: [&#39;#121122&#39;, &#39;rgba(3,4,5,0.4)&#39;, &#39;red&#39;],\n            symbolSize: [30, 100]\n        }\n    }\n]\n</code></pre>\n<p>If you want to define visual channels for target series and visualMap-piecewise component separately, you should do as follows:</p>\n<pre><code class=\"lang-javascript\">visualMap: [\n    {\n        ...,\n        // Define visual channels only for target series.\n        target: {\n            inRange: {\n                color: [&#39;#121122&#39;, &#39;rgba(3,4,5,0.4)&#39;, &#39;red&#39;],\n                symbolSize: [60, 200]\n            }\n        },\n        // Define visual channels only for visualMap-piecewise component.\n        controller: {\n            inRange: {\n                symbolSize: [30, 100]\n            }\n        }\n    }\n]\n</code></pre>\n<p>Or define as follows:</p>\n<pre><code class=\"lang-javascript\">visualMap: [\n    {\n        ...,\n        // Define visual channels for both target series and visualMap-piecewise component.\n        inRange: {\n            color: [&#39;#121122&#39;, &#39;rgba(3,4,5,0.4)&#39;, &#39;red&#39;],\n            symbolSize: [60, 200]\n        },\n        // Define visual channels only for visualMap-piecewise component, which\n        // will overlap the properties with the same name in the above common\n        // definition. (symbolSize is overlapped by [30, 100] while color\n        // keeps the original value)\n        controller: {\n            inRange: {\n                symbolSize: [30, 100]\n            }\n        }\n    }\n]\n</code></pre>\n<p><br></p>\n<hr>\n<p><strong>✦ About visual channels ✦</strong></p>\n<ul>\n<li><p>Various visual channels (such as <code class=\"codespan\">color</code>、<code class=\"codespan\">symbolSize</code> and ect.) can be defined in inRange at the same time and all of them will be apopted.</p>\n</li>\n<li><p>Basically visual channels <code class=\"codespan\">opacity</code> is recommended, rather than <code class=\"codespan\">colorAlpha</code>. The former controls the transparency of both graphical element and its attachments (like label), whereas the latter only controls the transparency of graphical element.</p>\n</li>\n<li><p>There are two approaches of visual mapping supported: &#39;Linear Mapping&#39; and &#39;Table Mapping&#39;.</p>\n</li>\n</ul>\n<p><br></p>\n<hr>\n<p><strong>✦ Linear Mapping to visual channel ✦</strong></p>\n<p><code class=\"codespan\">Linear Mapping</code> means that linear calculation will be performed on each dataValue (value of series.data), mapping them from the domain of <code class=\"codespan\">[visaulMap.min, visualMap.max]</code> to a given range of <code class=\"codespan\">[visual value 1, visual value 2]</code> and obtaining a final value (say visual value) for visual channel rendering.</p>\n<p>For instance, <code class=\"codespan\">[visualMap.min, visualMap.max]</code> is set to be <code class=\"codespan\">[0, 100]</code>, and there is series.data: <code class=\"codespan\">[50, 10, 100]</code>. We intend to map them to an <code class=\"codespan\">opacity</code> range <code class=\"codespan\">[0.4, 1]</code>, by which the size of value can be demostrated by the transparency of graphical elements. visualMap component will then linear calculate them and get opacity values <code class=\"codespan\">[0.7, 0.44, 1]</code>, cooresponding to each dataValue.</p>\n<p>We can also set the visual range inversely, such as <code class=\"codespan\">opacity: [1, 0.4]</code>, and the final mapping result for the given series.data above will be <code class=\"codespan\">[0.7, 0.96, 0.4]</code>.</p>\n<p>Notice: [visualMap.min, visualMap.max] should be set manually and is [0, 100] by default, but not <code class=\"codespan\">dataMin</code> and <code class=\"codespan\">dataMax</code> in series.data.</p>\n<p>How to configure visualMap component to do Linear Mapping?</p>\n<ul>\n<li><p>When use <a href=\"#visualMap-continuous\">visualMap-continuous</a>, or</p>\n</li>\n<li><p>When use <a href=\"#visualMap-piecewise\">visualMap-piecewise</a> and <a href=\"#visualMap-piecewise.categories\">visualMap-piecewise.categories</a> is not used.</p>\n</li>\n</ul>\n<p>About the value of visual channel (visual value):</p>\n<ul>\n<li><p>Basically <code class=\"codespan\">Array</code> is used to express the range of visual value, e.g., <code class=\"codespan\">color: [&#39;#333&#39;, &#39;#777&#39;]</code>.</p>\n</li>\n<li><p>Single <code class=\"codespan\">number</code> or single <code class=\"codespan\">string</code> can also be used, which will be converted to an <code class=\"codespan\">Array</code> by visualMap component. e.g.:  <code class=\"codespan\">opacity: 0.4</code> will be converted to <code class=\"codespan\">opacity: [0.4, 0.4]</code>, <code class=\"codespan\">color: &#39;#333&#39;</code> will be converted to <code class=\"codespan\">color: [&#39;#333&#39;, &#39;#333&#39;]</code>.</p>\n</li>\n<li><p>For visual channel <code class=\"codespan\">symbolSize</code>, <code class=\"codespan\">opacity</code>, <code class=\"codespan\">colorAlpha</code>, <code class=\"codespan\">colorLightness</code>, <code class=\"codespan\">colorSaturation</code>, <code class=\"codespan\">colorHue</code>, the range of visual value is always in the form of: <code class=\"codespan\">[visual value of visualMap.min, visual value of visualMap.max]</code>. For example, <code class=\"codespan\">colorLightness: [0.8, 0.2]</code> means that the dataValue in series.data that equals to <code class=\"codespan\">visualMap.min</code> (if any) will be mapped to lightness <code class=\"codespan\">0.8</code>, and the dataValue that equals to <code class=\"codespan\">visualMap.max</code> (if any) will be mapped to lightness <code class=\"codespan\">0.2</code>, and other dataValues will be mapped by the linear calculateion based on the domain of <code class=\"codespan\">[visualMap.min, visualMap.max]</code> and the range of <code class=\"codespan\">[0.8, 0.2]</code>.</p>\n</li>\n<li><p>For visual channel <code class=\"codespan\">color</code>, array is used, like: <code class=\"codespan\">[&#39;#333&#39;, &#39;#78ab23&#39;, &#39;blue&#39;]</code>, which means a color ribbon is formed based on the three color stops, and dataValues will be mapped to the ribbon. Specifically, the dataValue that equals to <code class=\"codespan\">visualMap.min</code> will be mapped onto <code class=\"codespan\">&#39;#333&#39;</code>, the dataValue that equals to <code class=\"codespan\">visualMap.max</code> will be mapped onto <code class=\"codespan\">&#39;blue&#39;</code>, and other dataValues will be piecewisely interpolated to get the final color.</p>\n</li>\n<li><p>For visual channel <code class=\"codespan\">symbol</code>, array is used, like: <code class=\"codespan\">[&#39;circle&#39;, &#39;rect&#39;, &#39;diamond&#39;]</code>, where the dataValue that equals to <code class=\"codespan\">visualMap.min</code> will be mapped onto <code class=\"codespan\">&#39;circle&#39;</code>, the dataValue that equals to <code class=\"codespan\">visualMap.max</code> will be mapped onto <code class=\"codespan\">&#39;diamond&#39;</code>, and other dataValues will be caculated based on the numerical distance to <code class=\"codespan\">visualMax.min</code> and to <code class=\"codespan\">visualMap.max</code>, and mapped onto one of <code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>.</p>\n</li>\n</ul>\n<p>About the possible value range of visual value:</p>\n<ul>\n<li><p><code class=\"codespan\">opacity</code>、<code class=\"codespan\">colorAlpha</code>、<code class=\"codespan\">colorLightness</code>、<code class=\"codespan\">colorSaturation</code>、<code class=\"codespan\">visual value</code></p>\n<p>  possible value range is <code class=\"codespan\">[0, 1]</code>.</p>\n</li>\n<li><p><code class=\"codespan\">colorHue</code>：</p>\n<p>  possible value range is <code class=\"codespan\">[0, 360]</code>.</p>\n</li>\n<li><p><code class=\"codespan\">color</code>：</p>\n<p>  color can use RGB expression, like <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>, or RGBA expression, like <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>, or Hex expression, like &#39;#ccc&#39;.</p>\n</li>\n<li><p><code class=\"codespan\">symbol</code>：</p>\n</li>\n</ul>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p><br></p>\n<hr>\n<p><strong>✦ Table Mapping to visual channel ✦</strong></p>\n<p><code class=\"codespan\">Table Mapping</code> could be used when dataValue (values in series.data, specified by <a href=\"#visualMap.dimension\">visualMap.dimension</a>) is enumerable and we intend to map them to visual value by looking up a given table.</p>\n<p>For instance, in a <a href=\"#visualMap-piecewise\">visualMap-piecewise</a> component, <a href=\"#visualMap-piecewise.categories\">visualMap-piecewise.categories</a> is set to <code class=\"codespan\">[&#39;Demon Hunter&#39;, &#39;Blademaster&#39;, &#39;Death Knight&#39;, &#39;Warden&#39;, &#39;Paladin&#39;]</code>. And there is series.data: <code class=\"codespan\">[&#39;Demon Hunter&#39;, &#39;Death Knight&#39;, &#39;Warden&#39;, &#39;Paladin&#39;]</code>. Then we can establish the lookup rule for color: <code class=\"codespan\">color: {&#39;Warden&#39;: &#39;red&#39;, &#39;Demon Hunter&#39;: &#39;black&#39;}</code>, by which the <code class=\"codespan\">visualMap</code> component will map <code class=\"codespan\">dataValue</code> to <code class=\"codespan\">color</code>.</p>\n<p>How to configure <code class=\"codespan\">visualMap</code> component to do <code class=\"codespan\">Table Mapping</code>?</p>\n<p>When use <a href=\"#visualMap-piecewise\">visualMap-piecewise</a> and <a href=\"#visualMap-piecewise.categories\">visualMap-piecewise.categories</a>is set.</p>\n<p>About the value of visual channel (visual value):</p>\n<p>Generally <code class=\"codespan\">Object</code> or <code class=\"codespan\">Array</code> is used, for instance:</p>\n<pre><code class=\"lang-javascript\">visualMap: {\n    type: &#39;piecewise&#39;,\n    // categories defines the items that to be displayed in visualMap-piecewise component.\n    categories: [\n        &#39;Demon Hunter&#39;, &#39;Blademaster&#39;, &#39;Death Knight&#39;, &#39;Warden&#39;, &#39;Paladin&#39;\n    ],\n    inRange: {\n        // visual value can be an Object：\n        color: {\n            &#39;Warden&#39;: &#39;red&#39;,\n            &#39;Demon Hunter&#39;: &#39;black&#39;,\n            &#39;&#39;: &#39;green&#39; // Blank string means that except &#39;Warden&#39; and &#39;Demon Hunter&#39;,\n                        // all other dataValues should be mapped to &#39;green&#39;.\n        }\n        // visual value can also be a single value,\n        // means that all dataValues should be mapped to the value.\n        color: &#39;green&#39;,\n        // visual value can also be a array, with the same length\n        // as the array of categories and one-one mapping onto it.\n        color: [&#39;red&#39;, &#39;black&#39;, &#39;green&#39;, &#39;yellow&#39;, &#39;white&#39;]\n    }\n}\n</code></pre>\n<p><a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/scatter-visualMap-categories&amp;edit=1&amp;reset=1\" target=\"_blank\">Example</a></p>\n<p><strong>✦ How to modity configurations of vsiual encoding? ✦</strong></p>\n<p>If you want to modify the configurations of visual encoding after chart been rendered (by invoke <code class=\"codespan\">setOption</code> to set the initial <code class=\"codespan\">option</code>), <code class=\"codespan\">setOption</code> can be used again to modify configurations of visual encoding. For instance:</p>\n<pre><code class=\"lang-javascript\">chart.setOption({\n    visualMap: {\n        inRange: {color: [&#39;red&#39;, &#39;blue&#39;]}\n    }\n});\n</code></pre>\n<p>Notice:</p>\n<ul>\n<li><p>These visualMap properties (i.e. <code class=\"codespan\">inRange</code>, <code class=\"codespan\">outOfRange</code>, <code class=\"codespan\">target</code>, <code class=\"codespan\">controller</code>) do not support &quot;merge&quot;, that is, anyone among them is modified when use <code class=\"codespan\">setOption</code> again, all of the original values of them will not be kept but erased. The &quot;merge&quot; brings complication in implemnentation and understanding, whereas &quot;erase all&quot; normalize the practise: once you want to modify some visual values, you should pass all of them to <code class=\"codespan\">setOption</code>, no matter they are to be changed.</p>\n</li>\n<li><p>This way, <code class=\"codespan\">getOption() -&gt; modify the gotten option -&gt; setOption(modified option)</code>, is strongly <strong>not recommended</strong>, for instance:</p>\n</li>\n</ul>\n<pre><code class=\"lang-javascript\">// Not recommended approach, regardless of its correctness:\n\nvar option = chart.getOption(); // Get the entire option.\noption.visualMap.inRange.color = [&#39;red&#39;, &#39;blue&#39;]; // modify color, which is what you want.\n\n// You have to modify those two properties, otherwise you will not get what you want.\noption.visualMap.target.inRange.color = [&#39;red&#39;, &#39;blue&#39;];\noption.visualMap.controller.inRange.color = [&#39;red&#39;, &#39;blue&#39;];\n\nchart.setOption(option); // set the modified option back.\n// You should not use this approach, but use the\n// approach demostrated before this example.\n</code></pre>\n<p><strong>Notice:</strong> There is default color <code class=\"codespan\">[&#39;#f6efa6&#39;, &#39;#d88273&#39;, &#39;#bf444c&#39;]</code> in <code class=\"codespan\">inRange</code> if you not set <code class=\"codespan\">inRange</code>. If you dont want it, set <code class=\"codespan\">inRange: {color: null}</code> to disable it.</p>\n"},"outOfRange":{"type":["Object"],"description":"<p>Define visual channels that will mapped from dataValues that are <strong>out of selected range</strong>. User can interact with visualMap component and make a seleced range by mouse or touch.</p>\n<p>See available configurations in <a href=\"#visualMap-piecewise.inRange\">visualMap-piecewise.inRange</a></p>\n"},"controller":{"type":["Object"],"description":"<p>Property <code class=\"codespan\">inRange</code> and <code class=\"codespan\">outOfRange</code> can be set within property <code class=\"codespan\">controller</code>, which means those <code class=\"codespan\">inRange</code> and <code class=\"codespan\">outOfRange</code> are only used on the controller (<code class=\"codespan\">visualMap</code> component itself), but are not used on chart (series). This property is useful in some scenarios when the view of controller needs to be customized in detail.</p>\n","properties":{"inRange":{"type":["Object"],"description":"<p>Define visual channels that will mapped from dataValues that are <strong>in selected range</strong>. User can interact with visualMap component and make a seleced range by mouse or touch.</p>\n<p>See available configurations in <a href=\"#visualMap-piecewise.inRange\">visualMap-piecewise.inRange</a></p>\n"},"outOfRange":{"type":["Object"],"description":"<p>Define visual channels that will mapped from dataValues that are <strong>out of selected range</strong>. User can interact with visualMap component and make a seleced range by mouse or touch.</p>\n<p>See available configurations in <a href=\"#visualMap-piecewise.inRange\">visualMap-piecewise.inRange</a></p>\n"}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":4},"left":{"type":["string","number"],"description":"<p>Distance between visualMap  component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":0},"top":{"type":["string","number"],"description":"<p>Distance between visualMap  component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"auto"},"right":{"type":["string","number"],"description":"<p>Distance between visualMap  component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":"auto"},"bottom":{"type":["string","number"],"description":"<p>Distance between visualMap  component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":0},"orient":{"type":["string"],"description":"<p>How to layout the visualMap component, <code class=\"codespan\">&#39;horizontal&#39;</code> or <code class=\"codespan\">&#39;vertical&#39;</code>.</p>\n","default":"'vertical'"},"padding":{"type":["number","Array"],"description":"\n\n<p>visualMap-piecewise space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"backgroundColor":{"type":["Color"],"description":"<p>background color of visualMap component.</p>\n","default":"'rgba(0,0,0,0)'"},"borderColor":{"type":["Color"],"description":"<p>border color of visualMap component.</p>\n","default":"'#ccc'"},"borderWidth":{"type":["number"],"description":"<p>border width of visualMap component, with unit: px.</p>\n","default":0},"color":{"type":["Array"],"description":"<p>This property remains only for compatibility with ECharts2, and is not recommended in ECharts3. It is recommended to configure color in <a href=\"#visualMap-piecewise.inRange\">visualMap-piecewise.inRange</a>, or <a href=\"#visualMap-piecewise.outOfRange\">visualMap-piecewise.outOfRange</a> if needed.</p>\n<p>If you persist in using it, the following issue should be noticed: the sequence of dataValues that are mapped to colorValues in property <code class=\"codespan\">color</code> is from <code class=\"codespan\">large</code> to <code class=\"codespan\">small</code>, whereas that in <a href=\"#visualMap-piecewise.inRange\">visualMap-piecewise.inRange</a> or <a href=\"#visualMap-piecewise.outOfRange\">visualMap-piecewise.outOfRange</a> is from <code class=\"codespan\">small</code> to <code class=\"codespan\">large</code>.</p>\n","default":"['#bf444c', '#d88273', '#f6efa6']"},"textStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>visualMap  text color.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"#333"},"fontStyle":{"type":["string"],"description":"\n\n<p>visualMap  font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p>visualMap  font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p>visualMap  font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p>visualMap  font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"formatter":{"type":["string","Function"],"description":"<p>the formatter tool for label.</p>\n<ul>\n<li><p>If it was set as a <code class=\"codespan\">string</code>, it refers to a template, for instance: <code class=\"codespan\">aaaa{value}bbbb{value2}</code>, where <code class=\"codespan\">{value}</code> and <code class=\"codespan\">{value2}</code> represents the current selected range of dataValues.</p>\n</li>\n<li><p>If it was set as a <code class=\"codespan\">Function</code>, it refers to a callback function, for instance:</p>\n</li>\n</ul>\n<pre><code class=\"lang-javascript\">formatter: function (value, value2) {\n    return &#39;aaaa&#39; + value + &#39;bbbb&#39; + value2;\n}\n</code></pre>\n"}}}]},"description":"<p><code class=\"codespan\">visualMap</code> is a type of component for visual encoding, which maps the data to visual channels, including:</p>\n<ul>\n<li><code class=\"codespan\">symbol</code>: Type of symbol.</li>\n<li><code class=\"codespan\">symbolSize</code>: Symbol size.</li>\n<li><code class=\"codespan\">color</code>: Symbol color.</li>\n<li><code class=\"codespan\">colorAlpha</code>: Symbol alpha channel.</li>\n<li><code class=\"codespan\">opacity</code>: Opacity of symbol and others (like labels).</li>\n<li><code class=\"codespan\">colorLightness</code>: Lightness in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n<li><code class=\"codespan\">colorSaturation</code>: Saturation in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n<li><code class=\"codespan\">colorHue</code>: Hue in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n</ul>\n<p>Myltiple <code class=\"codespan\">visualMap</code> component could be defined in a chart instance, which enable that different dimensions of a series data are mapped to different visual channels.</p>\n<p><code class=\"codespan\">visualMap</code> could be defined as <a href=\"#visualMap-piecewise\">Piecewise (visualMapPiecewise)</a> or <a href=\"#visualMap-continuous\">Continuous (visualMapContinuous)</a>, which is distinguished by the property <code class=\"codespan\">type</code>. For instance:</p>\n<pre><code class=\"lang-javascript\">option = {\n    visualMap: [\n        { // the first visualMap component\n            type: &#39;continuous&#39;, // defined to be continuous visualMap\n            ...\n        },\n        { // the second visualMap component\n            type: &#39;piecewise&#39;, // defined to be piecewise visualMap\n            ...\n        }\n    ],\n    ...\n};\n</code></pre>\n<p><br>\n<strong>✦ Configure mapping ✦</strong></p>\n<p>The dimension of <a href=\"#series.data\">series.data</a> can be specified by <a href=\"#visualMap.dimension\">visualMap.dimension</a>, from which the value can be retrieved and mapped onto visual channels, which can be defined in <a href=\"#visualMap.inRange\">visualMap.inRange</a> and <a href=\"#visualMap.outOfRange\">visualMap.outOfRange</a>.</p>\n<p><br>\nIn series that controlled by visualMap, if a data item needs to escape from controlled by visualMap, you can set like this:</p>\n<pre><code>series: {\n    type: &#39;...&#39;,\n    data: [\n        {name: &#39;Shanghai&#39;, value: 251},\n        {name: &#39;Haikou&#39;, value: 21},\n        // Mark as `visualMap: false`, then this item does not controlled by visualMap any more,\n        // and series visual config (like color, symbol, ...) can be used to this item.\n        {name: &#39;Beijing&#39;, value: 821, },\n        ...\n    ]\n}\n</code></pre><p><br>\n<strong>✦ The relationship between visualMap of ECharts3 and dataRange of ECharts2 ✦</strong></p>\n<p><code class=\"codespan\">visualMap</code> is renamed from the <code class=\"codespan\">dataRange</code> of ECharts2, and the scope of functionalities are extended a lot. The configurations of <code class=\"codespan\">dataRange</code> are still compatible in ECharts3, which automatically convert them to <code class=\"codespan\">visualMap</code>. It is recommended to use <code class=\"codespan\">visualMap</code> instead of <code class=\"codespan\">dataRange</code> in ECharts3.</p>\n<p><br>\n<strong>✦ The detailed configurations of visualMap are elaborated as follows. ✦</strong></p>\n<p><br>\n<br></p>\n","properties":{}},"tooltip":{"type":["Object"],"description":"<p>Tooltip component.</p>\n<hr>\n<p><strong>General Introduction:</strong></p>\n<p>tooltip can be configured on different places:</p>\n<ul>\n<li><p>Configured on global: <a href=\"#tooltip\">tooltip</a></p>\n</li>\n<li><p>Configured in a coordinate system: <a href=\"#grid.tooltip\">grid.tooltip</a>, <a href=\"#polar.tooltip\">polar.tooltip</a>, <a href=\"#single.tooltip\">single.tooltip</a></p>\n</li>\n<li><p>Configured in a series: <a href=\"#series.tooltip\">series.tooltip</a></p>\n</li>\n<li><p>Configured in each item of <code class=\"codespan\">series.data</code>: <a href=\"#series.data.tooltip\">series.data.tooltip</a></p>\n</li>\n</ul>\n<hr>\n\n\n\n","exampleBaseOptions":[{"code":"\nvar base = +new Date(2016, 9, 3);\nvar oneDay = 24 * 3600 * 1000;\nvar valueBase = Math.random() * 300;\nvar valueBase2 = Math.random() * 50;\nvar data = [];\nvar data2 = [];\n\nfor (var i = 1; i < 10; i++) {\n    var now = new Date(base += oneDay);\n    var dayStr = [now.getFullYear(), now.getMonth() + 1, now.getDate()].join('-');\n\n    valueBase = Math.round((Math.random() - 0.5) * 20 + valueBase);\n    valueBase <= 0 && (valueBase = Math.random() * 300);\n    data.push([dayStr, valueBase]);\n\n    valueBase2 = Math.round((Math.random() - 0.5) * 20 + valueBase2);\n    valueBase2 <= 0 && (valueBase2 = Math.random() * 50);\n    data2.push([dayStr, valueBase2]);\n}\n\nconst option = {\n    legend: {\n        top: 'bottom',\n        data: ['意向']\n    },\n    tooltip: {\n        triggerOn: 'none',\n        alwaysShowContent: true,\n        position: function (pt) {\n            return [pt[0], 130];\n        }\n    },\n    xAxis: {\n        type: 'time',\n        // boundaryGap: [0, 0],\n        axisPointer: {\n            value: '2016-10-7',\n            snap: true,\n            label: {\n                show: true,\n                formatter: function (params) {\n                    return echarts.format.formatTime('yyyy-MM-dd', params.value);\n                }\n            },\n            handle: {\n                show: true\n            }\n        },\n        splitLine: {\n            show: false\n        }\n    },\n    yAxis: {\n        type: 'value',\n        axisTick: {\n            inside: true\n        },\n        splitLine: {\n            show: false\n        },\n        axisLabel: {\n            inside: true\n        },\n        z: 10\n    },\n    grid: {\n        top: 110,\n        left: 15,\n        right: 15,\n        height: 160\n    },\n    series: [\n        {\n            name: '模拟数据',\n            type: 'line',\n            smooth: true,\n            symbol: 'circle',\n            symbolSize: 5,\n            sampling: 'average',\n            itemStyle: {\n                color: '#8ec6ad'\n            },\n            stack: 'a',\n            areaStyle: {\n            },\n            data: data\n        },\n        {\n            name: '模拟数据',\n            type: 'line',\n            smooth: true,\n            stack: 'a',\n            symbol: 'circle',\n            symbolSize: 5,\n            sampling: 'average',\n            itemStyle: {\n                color: '#d68262'\n            },\n            areaStyle: {\n            },\n            data: data2\n        }\n\n    ]\n};\n","name":"tooltip","title":"提示框","title-en":"Tooltip"}],"properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the tooltip component, including tooltip floating layer and <a href=\"#tooltip.axisPointer\">axisPointer</a>.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"trigger":{"type":["string"],"description":"\n\n<p>Type of triggering.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;item&#39;</code></p>\n<p>  Triggered by data item, which is mainly used for charts that don&#39;t have a category axis like scatter charts or pie charts.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;axis&#39;</code></p>\n<p>  Triggered by axes, which is mainly used for charts that have category axes, like bar charts or line charts.</p>\n<p> ECharts 2.x only supports axis trigger for category axis. In ECharts 3, it is supported for all types of axes in <a href=\"#grid\">grid</a> or <a href=\"#polar\">polar</a>. Also, you may assign axis with <a href=\"#tooltip.axisPointer.axis\">axisPointer.axis</a>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code></p>\n<p>  Trigger nothing.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"item,axis,none","default":"item"},"default":"'item'"},"axisPointer":{"type":["Object"],"description":"<p>Configuration item for axisPointer.</p>\n<p><code class=\"codespan\">tooltip.axisPointer</code> is like syntactic sugar of axisPointer settings on axes (for example, <a href=\"#xAxis.axisPointer\">xAxis.axisPointer</a> or <a href=\"#angleAxis.axisPointer\">angleAxis.axisPointer</a>). More detailed features can be configured on <code class=\"codespan\">someAxis.axisPointer</code>. But in common cases, using <code class=\"codespan\">tooltip.axisPointer</code> is more convenient.</p>\n<blockquote>\n<p><strong>Notice:</strong> configurations of <code class=\"codespan\">tooltip.axisPointer</code> has lower priority than that of <code class=\"codespan\">someAxis.axisPointer</code>.</p>\n</blockquote>\n<hr>\n<p><code class=\"codespan\">axisPointer</code> is a tool for displaying reference line and axis value under mouse pointer.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/candlestick-axisPointer&edit=1&reset=1\" width=\"600\" height=\"450\"></iframe>\n\n\n<p>In the demo above, <a href=\"#axisPointer.link\">axisPointer.link</a> is used to link axisPointer from different coordinate systems.</p>\n<p><code class=\"codespan\">axisPointer</code> can also be used on touch device, where user can drag the button to move the reference line and label.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-tooltip-touch&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n<p>In the cases that more than one axis exist, axisPointer helps to look inside the data.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=multiple-y-axis&edit=1&reset=1\" width=\"600\" height=\"300\"></iframe>\n\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=multiple-x-axis&edit=1&reset=1\" width=\"600\" height=\"300\"></iframe>\n\n\n\n<hr>\n<blockquote>\n<p><strong>Notice:</strong>\nGenerally, axisPointers is configured in each axes who need them (for example <a href=\"#xAxis.axisPointer\">xAxis.axisPointer</a>), or configured in <code class=\"codespan\">tooltip</code> (for example <a href=\"#tooltip.axisPointer\">tooltip.axisPointer</a>).</p>\n</blockquote>\n<blockquote>\n<p>But these configurations can only be configured in global axisPointer:\n<a href=\"#axisPointer.triggerOn\">axisPointer.triggerOn</a>, <a href=\"#axisPointer.link\">axisPointer.link</a>.</p>\n</blockquote>\n<hr>\n<hr>\n<p><strong>How to display axisPointer:</strong></p>\n<p>In <a href=\"#grid\">cartesian (grid)</a> and <a href=\"#single\">polar](~polar) and (single axis</a>, each axis has its own axisPointer.</p>\n<p>Those axisPointer will not be displayed by default, utill configured as follows:</p>\n<ul>\n<li><p>Set <code class=\"codespan\">someAxis.axisPointer.show</code> (like <a href=\"#xAxis.axisPointer.show\">xAxis.axisPointer.show</a>) as <code class=\"codespan\">true</code>. Then axisPointer of this axis will be displayed.</p>\n</li>\n<li><p>Set <a href=\"#tooltip.trigger\">tooltip.trigger</a> as <code class=\"codespan\">&#39;axis&#39;</code>, or set <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> as <code class=\"codespan\">&#39;cross&#39;</code>. Then coordinate system will automatically chose the axes who will display their axisPointers. (<a href=\"#tooltip.axisPointer.axis\">tooltip.axisPointer.axis</a> can be used to change the choice.) Notice, <code class=\"codespan\">axis.axisPointer</code> will override <code class=\"codespan\">tooltip.axisPointer</code> settings.</p>\n</li>\n</ul>\n<hr>\n<p><strong>How to display the label of axisPointer:</strong></p>\n<p>The label of axisPointer will not be displayed by default(namely, only reference line will be displayed by default), utill configured as follows:</p>\n<ul>\n<li><p>Set <code class=\"codespan\">someAxis.axisPointer.label.show</code> (for example <a href=\"#xAxis.axisPointer.show\">xAxis.axisPointer.label.show</a>) as <code class=\"codespan\">true</code>. Then the label of the axisPointer will be displayed.</p>\n</li>\n<li><p>Set <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> as  <code class=\"codespan\">&#39;cross&#39;</code>. Then the label of the crossed axisPointers will be displayed.</p>\n</li>\n</ul>\n<hr>\n<p><strong>How to configure axisPointer on touch device:</strong></p>\n<p>Set <code class=\"codespan\">someAxis.axisPointer.handle.show</code> (for example <a href=\"#xAxis.axisPointer.handle.show\">xAxis.axisPointer.handle.show</a> as <code class=\"codespan\">true</code>. Then the button for dragging will be displayed. (This feature is not supported on polar).</p>\n<p><strong>Notice:</strong>\nIf tooltip does not work well in this case, try to set<a href=\"#tooltip.triggerOn\">tooltip.triggerOn</a> as <code class=\"codespan\">&#39;none&#39;</code> (for the effect: show tooltip when finger holding on the button, and hide tooltip after finger left the button), or set <a href=\"#tooltip.alwaysShowContent\">tooltip.alwaysShowContent</a> as <code class=\"codespan\">true</code> (then tooltip will always be displayed).</p>\n<p>See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-tooltip-touch&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>.</p>\n<hr>\n<p><strong>Snap to point</strong></p>\n<p>In value axis and time axis, if <a href=\"#xAxis.axisPointer.snap\">snap</a> is set as true, axisPointer will snap to point automatically.</p>\n<hr>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Indicator type.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;line&#39;</code> line indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;shadow&#39;</code> shadow crosshair indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code> no indicator displayed.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;cross&#39;</code> crosshair indicator, which is actually the shortcut of enable two axisPointers of two orthometric axes.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"none,line,shadow,cross","default":"line"},"default":"'line'"},"axis":{"type":["string"],"description":"<p>The coordinate axis, which could be <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, <code class=\"codespan\">&#39;radius&#39;</code>, or <code class=\"codespan\">&#39;angle&#39;</code>. By default, each coordinate system will automatically chose the axes whose will display its axisPointer (category axis or time axis is used by default).</p>\n","default":"'auto'"},"snap":{"type":["boolean"],"description":"<p>Whether snap to point automatically. The default value is auto determined.</p>\n<p>This feature usually makes sense in value axis and time axis, where tiny points can be seeked automatically.</p>\n"},"z":{"type":["number"],"description":"<p>z value, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n"},"label":{"type":["Object"],"description":"<p>label of axisPointer</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label. Label will not show by default. But if <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, label will be displayed automatically.</p>\n","default":false},"precision":{"type":["number","string"],"description":"<p>The precision of value in label. It is auto determined by default. You can also set it as <code class=\"codespan\">&#39;2&#39;</code>, which indicates that two decimal fractions are reserved.</p>\n","default":"'auto'"},"formatter":{"type":["string","Function"],"description":"<p>The formatter of label.</p>\n<p>If set as <code class=\"codespan\">string</code>, for example it can be: <code class=\"codespan\">formatter: &#39;some text {value} some text</code>, where <code class=\"codespan\">{value}</code> will be replaced by axis value automatically.</p>\n<p>If set as <code class=\"codespan\">function</code>:</p>\n<p><strong>Parameters:</strong></p>\n<p><code class=\"codespan\">{Object}</code> params: Including fields as follows:</p>\n<p><code class=\"codespan\">{Object}</code> params.value: current value of this axis. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;category&#39;</code>, it is one of the value in <code class=\"codespan\">axis.data</code>. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;time&#39;</code>, it is a timestamp.</p>\n<p><code class=\"codespan\">{Array.&lt;Object&gt;}</code> params.seriesData: An array, containing info of nearest points. Each item is:</p>\n<p><code class=\"codespan\">{string}</code> params.axisDimension: The dimension name of the axis. For example, in catesian it will be <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, and in polar it will be <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code>.</p>\n<p><code class=\"codespan\">{number}</code> params.axisIndex: The index of the axis, for example, <code class=\"codespan\">0</code>,<code class=\"codespan\">1</code>, <code class=\"codespan\">2</code>, ...</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>Each item also includes axis infomation:</p>\n<pre><code class=\"lang-js\">{\n    axisDim: &#39;x&#39;, // &#39;x&#39;, &#39;y&#39;, &#39;angle&#39;, &#39;radius&#39;, &#39;single&#39;\n    axisId: &#39;xxx&#39;,\n    axisName: &#39;xxx&#39;,\n    axisIndex: 3,\n    axisValue: 121, // The current value of axisPointer\n    axisValueLabel: &#39;text of value&#39;\n}\n</code></pre>\n<p><strong>Return:</strong></p>\n<p>The string to be displayed.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">formatter: function (params) {\n    // If axis.type is &#39;time&#39;\n    return &#39;some text&#39; + echarts.format.formatTime(params.value);\n}\n</code></pre>\n","default":null},"margin":{"type":["boolean"],"description":"<p>Distance between label and axis.</p>\n","default":3},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"padding":{"type":["string","Array"],"description":"\n\n<p>axisPointer space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":"[5, 7, 5, 7]"},"backgroundColor":{"type":["string"],"description":"<p>Background color of label, the same as <a href=\"#xAxis.axisLine.lineStyle.color\">axis.axisLine.lineStyle.color</a> by default.</p>\n","default":"'auto'"},"borderColor":{"type":["string"],"description":"<p>Border color of label.</p>\n","default":null},"borderWidth":{"type":["string"],"description":"<p>Border width of label.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"lineStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;line&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#555"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"shadowStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;shadow&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'rgba(150,150,150,0.3)"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"crossStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;cross&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#555"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"dashed"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":200},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"exponentialOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"showContent":{"type":["boolean"],"description":"\n\n<p>Whether to show the tooltip floating layer, whose default value is true. It should be configurated to be <code class=\"codespan\">false</code>, if you only need tooltip to trigger the event or show the axisPointer without content.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"alwaysShowContent":{"type":["boolean"],"description":"\n\n<p>Whether to show tooltip content all the time. By default, it will be hidden <a href=\"#tooltip.hideDelay\">after some time</a>. It can be set to be <code class=\"codespan\">true</code> to preserve displaying.</p>\n<p>This attribute is newly added to ECharts 3.0.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"triggerOn":{"type":["string"],"description":"\n\n<p>Conditions to trigger tooltip. Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;mousemove&#39;</code></p>\n<p>  Trigger when mouse moves.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;click&#39;</code></p>\n<p>  Trigger when mouse clicks.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;mousemove|click&#39;</code></p>\n<p>  Trigger when mouse clicks and moves.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code></p>\n<p>  Do not triggered by <code class=\"codespan\">&#39;mousemove&#39;</code> and <code class=\"codespan\">&#39;click&#39;</code>. Tooltip can be triggered and hidden manually by calling <a href=\"api.html#action.tooltip.showTip\" target=\"_blank\">action.tooltip.showTip</a> and <a href=\"api.html#action.tooltip.hideTip\" target=\"_blank\">action.tooltip.hideTip</a>. It can also be triggered by <a href=\"#xAxis.axisPointer.handle\">axisPointer.handle</a> in this case.</p>\n</li>\n</ul>\n<p>This attribute is new to ECharts 3.0.</p>\n","uiControl":{"type":"enum","options":"mousemove,click"},"default":"'mousemove|click'"},"showDelay":{"type":["number"],"description":"\n\n<p>Delay time for showing tooltip, in ms. No delay by default, and it is not recommended to set. Only valid when <a href=\"#tooltip.triggerOn\">triggerOn</a> is set to be <code class=\"codespan\">&#39;mousemove&#39;</code>.</p>\n","uiControl":{"type":"number","min":"0","step":"20"},"default":0},"hideDelay":{"type":["number"],"description":"\n\n<p>Delay time for hiding tooltip, in ms. It will be invalid when <a href=\"#tooltip.alwaysShowContent\">alwaysShowContent</a> is <code class=\"codespan\">true</code>.</p>\n","uiControl":{"type":"number","min":"0","step":"20","default":"100"},"default":100},"enterable":{"type":["boolean"],"description":"\n\n<p>Whether mouse is allowed to enter the floating layer of tooltip, whose default value is false. If you need to interact in the tooltip like with links or buttons, it can be set as <code class=\"codespan\">true</code>.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":true},"renderMode":{"type":["string"],"description":"\n\n<p>Render mode for tooltip. By default, it is set to be <code class=\"codespan\">&#39;html&#39;</code> so that extra DOM element is used for tooltip. It can also set to be <code class=\"codespan\">&#39;richText&#39;</code> so that the tooltip will be rendered inside Canvas (SVG rich text is not implemented yet). This is very useful for environments that don&#39;t have DOM, such as Wechat applications.</p>\n","uiControl":{"type":"enum","options":"html,richText","default":"html"},"default":"'html'"},"confine":{"type":["boolean"],"description":"\n\n<p>Whether confine tooltip content in the view rect of chart instance.</p>\n<p>Useful when tooltip is cut because of <code class=\"codespan\">&#39;overflow: hidden&#39;</code> set on outer dom of chart instance, or because of narrow screen on mobile.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"appendToBody":{"type":["boolean"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v4.7.0</code></p>\n</blockquote>\n<p>Whether to append the tooltip DOM element as a child of the <code class=\"codespan\">&lt;body&gt;</code> of the HTML page, when using <a href=\"#tooltip.renderMode\">renderMode</a> <code class=\"codespan\">&#39;html&#39;</code>.</p>\n<p>By default <code class=\"codespan\">false</code>, means that the tooltip DOM element will be one of a descendant of its echarts DOM container. But that means that the tooltip might be cut when overflow the container if some of the ancestors DOM element of the echarts container are styled with <code class=\"codespan\">overflow: hidden</code>. This case could also be resolved by setting <a href=\"#tooltip.confine\">tooltip.confine</a>, but it might not suitable for all scenarios.</p>\n<p>Here we provide <code class=\"codespan\">appendToBody: true</code> to auto append the tooltip element to <code class=\"codespan\">&lt;body&gt;</code>, which is a common way to resolve this kind of issue. But <code class=\"codespan\">true</code> is not set as a default value because to void to bring break change for some cases where tooltip is deeply customized and to void some unexpected bad cases.</p>\n<p>Note that it also works when CSS transform used.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"className":{"type":["string"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Specify the classes for the tooltip root DOM. (Only works in <a href=\"#tooltip.renderMode\"><code class=\"codespan\">html</code></a> render mode).</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">className: &#39;echarts-tooltip echarts-tooltip-dark&#39;\n</code></pre>\n","uiControl":{"type":"text"}},"transitionDuration":{"type":["number"],"description":"\n\n<p>The transition duration of tooltip&#39;s animation, in seconds. When it is set to be 0, it would move closely with the mouse.</p>\n","uiControl":{"type":"number","min":"0","step":"0.1","default":"0.4"},"default":0.4},"position":{"type":["string","Array"],"description":"<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n\n\n\n\n\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n\n\n\n\n\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n\n\n\n\n\n\n\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"},"order":{"type":["string"],"description":"\n\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Tooltip order for multiple series. Defaults is <code class=\"codespan\">&#39;seriesAsc&#39;</code>.</p>\n<p>Conditions to order tooltip. Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;seriesAsc&#39;</code></p>\n<p>  Base on series declaration, ascending order tooltip.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;seriesDesc&#39;</code></p>\n<p>  Base on series declaration, descending order tooltip.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;valueAsc&#39;</code></p>\n<p>  Base on value, ascending order tooltip, only for numberic value.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;valueDesc&#39;</code></p>\n<p>  Base on value, descending order tooltip, only for numberic value.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"seriesAsc,seriesDesc,valueAsc,valueDesc","default":"seriesAsc"},"default":"'seriesAsc'"}}},"axisPointer":{"type":["Object"],"description":"<p>This is the global configurations of axisPointer.</p>\n<hr>\n<p><code class=\"codespan\">axisPointer</code> is a tool for displaying reference line and axis value under mouse pointer.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/candlestick-axisPointer&edit=1&reset=1\" width=\"600\" height=\"450\"></iframe>\n\n\n<p>In the demo above, <a href=\"#axisPointer.link\">axisPointer.link</a> is used to link axisPointer from different coordinate systems.</p>\n<p><code class=\"codespan\">axisPointer</code> can also be used on touch device, where user can drag the button to move the reference line and label.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-tooltip-touch&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n<p>In the cases that more than one axis exist, axisPointer helps to look inside the data.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=multiple-y-axis&edit=1&reset=1\" width=\"600\" height=\"300\"></iframe>\n\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=multiple-x-axis&edit=1&reset=1\" width=\"600\" height=\"300\"></iframe>\n\n\n\n<hr>\n<blockquote>\n<p><strong>Notice:</strong>\nGenerally, axisPointers is configured in each axes who need them (for example <a href=\"#xAxis.axisPointer\">xAxis.axisPointer</a>), or configured in <code class=\"codespan\">tooltip</code> (for example <a href=\"#tooltip.axisPointer\">tooltip.axisPointer</a>).</p>\n</blockquote>\n<blockquote>\n<p>But these configurations can only be configured in global axisPointer:\n<a href=\"#axisPointer.triggerOn\">axisPointer.triggerOn</a>, <a href=\"#axisPointer.link\">axisPointer.link</a>.</p>\n</blockquote>\n<hr>\n<hr>\n<p><strong>How to display axisPointer:</strong></p>\n<p>In <a href=\"#grid\">cartesian (grid)</a> and <a href=\"#single\">polar](~polar) and (single axis</a>, each axis has its own axisPointer.</p>\n<p>Those axisPointer will not be displayed by default, utill configured as follows:</p>\n<ul>\n<li><p>Set <code class=\"codespan\">someAxis.axisPointer.show</code> (like <a href=\"#xAxis.axisPointer.show\">xAxis.axisPointer.show</a>) as <code class=\"codespan\">true</code>. Then axisPointer of this axis will be displayed.</p>\n</li>\n<li><p>Set <a href=\"#tooltip.trigger\">tooltip.trigger</a> as <code class=\"codespan\">&#39;axis&#39;</code>, or set <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> as <code class=\"codespan\">&#39;cross&#39;</code>. Then coordinate system will automatically chose the axes who will display their axisPointers. (<a href=\"#tooltip.axisPointer.axis\">tooltip.axisPointer.axis</a> can be used to change the choice.) Notice, <code class=\"codespan\">axis.axisPointer</code> will override <code class=\"codespan\">tooltip.axisPointer</code> settings.</p>\n</li>\n</ul>\n<hr>\n<p><strong>How to display the label of axisPointer:</strong></p>\n<p>The label of axisPointer will not be displayed by default(namely, only reference line will be displayed by default), utill configured as follows:</p>\n<ul>\n<li><p>Set <code class=\"codespan\">someAxis.axisPointer.label.show</code> (for example <a href=\"#xAxis.axisPointer.show\">xAxis.axisPointer.label.show</a>) as <code class=\"codespan\">true</code>. Then the label of the axisPointer will be displayed.</p>\n</li>\n<li><p>Set <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> as  <code class=\"codespan\">&#39;cross&#39;</code>. Then the label of the crossed axisPointers will be displayed.</p>\n</li>\n</ul>\n<hr>\n<p><strong>How to configure axisPointer on touch device:</strong></p>\n<p>Set <code class=\"codespan\">someAxis.axisPointer.handle.show</code> (for example <a href=\"#xAxis.axisPointer.handle.show\">xAxis.axisPointer.handle.show</a> as <code class=\"codespan\">true</code>. Then the button for dragging will be displayed. (This feature is not supported on polar).</p>\n<p><strong>Notice:</strong>\nIf tooltip does not work well in this case, try to set<a href=\"#tooltip.triggerOn\">tooltip.triggerOn</a> as <code class=\"codespan\">&#39;none&#39;</code> (for the effect: show tooltip when finger holding on the button, and hide tooltip after finger left the button), or set <a href=\"#tooltip.alwaysShowContent\">tooltip.alwaysShowContent</a> as <code class=\"codespan\">true</code> (then tooltip will always be displayed).</p>\n<p>See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-tooltip-touch&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>.</p>\n<hr>\n<p><strong>Snap to point</strong></p>\n<p>In value axis and time axis, if <a href=\"#xAxis.axisPointer.snap\">snap</a> is set as true, axisPointer will snap to point automatically.</p>\n<hr>\n<hr>\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"show":{"type":["boolean"],"description":"\n\n<p>axisPointer will not be displayed by default. But if <a href=\"#tooltip.trigger\">tooltip.trigger</a> is set as <code class=\"codespan\">&#39;axis&#39;</code> or <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, axisPointer will be displayed automatically. Each coordinate system will automatically chose the axes whose will display its axisPointer. <a href=\"#tooltip.axisPointer.axis\">tooltip.axisPointer.axis</a> can be used to change the choice.</p>\n","uiControl":{"type":"boolean"},"default":false},"type":{"type":["string"],"description":"\n\n<p>Indicator type.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;line&#39;</code> line indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;shadow&#39;</code> shadow crosshair indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code> no indicator displayed.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"line,shadow,none"},"default":"'line'"},"snap":{"type":["boolean"],"description":"<p>Whether snap to point automatically. The default value is auto determined.</p>\n<p>This feature usually makes sense in value axis and time axis, where tiny points can be seeked automatically.</p>\n"},"z":{"type":["number"],"description":"<p>z value, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n"},"label":{"type":["Object"],"description":"<p>label of axisPointer</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label. Label will not show by default. But if <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, label will be displayed automatically.</p>\n","default":false},"precision":{"type":["number","string"],"description":"<p>The precision of value in label. It is auto determined by default. You can also set it as <code class=\"codespan\">&#39;2&#39;</code>, which indicates that two decimal fractions are reserved.</p>\n","default":"'auto'"},"formatter":{"type":["string","Function"],"description":"<p>The formatter of label.</p>\n<p>If set as <code class=\"codespan\">string</code>, for example it can be: <code class=\"codespan\">formatter: &#39;some text {value} some text</code>, where <code class=\"codespan\">{value}</code> will be replaced by axis value automatically.</p>\n<p>If set as <code class=\"codespan\">function</code>:</p>\n<p><strong>Parameters:</strong></p>\n<p><code class=\"codespan\">{Object}</code> params: Including fields as follows:</p>\n<p><code class=\"codespan\">{Object}</code> params.value: current value of this axis. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;category&#39;</code>, it is one of the value in <code class=\"codespan\">axis.data</code>. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;time&#39;</code>, it is a timestamp.</p>\n<p><code class=\"codespan\">{Array.&lt;Object&gt;}</code> params.seriesData: An array, containing info of nearest points. Each item is:</p>\n<p><code class=\"codespan\">{string}</code> params.axisDimension: The dimension name of the axis. For example, in catesian it will be <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, and in polar it will be <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code>.</p>\n<p><code class=\"codespan\">{number}</code> params.axisIndex: The index of the axis, for example, <code class=\"codespan\">0</code>,<code class=\"codespan\">1</code>, <code class=\"codespan\">2</code>, ...</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>Each item also includes axis infomation:</p>\n<pre><code class=\"lang-js\">{\n    axisDim: &#39;x&#39;, // &#39;x&#39;, &#39;y&#39;, &#39;angle&#39;, &#39;radius&#39;, &#39;single&#39;\n    axisId: &#39;xxx&#39;,\n    axisName: &#39;xxx&#39;,\n    axisIndex: 3,\n    axisValue: 121, // The current value of axisPointer\n    axisValueLabel: &#39;text of value&#39;\n}\n</code></pre>\n<p><strong>Return:</strong></p>\n<p>The string to be displayed.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">formatter: function (params) {\n    // If axis.type is &#39;time&#39;\n    return &#39;some text&#39; + echarts.format.formatTime(params.value);\n}\n</code></pre>\n","default":null},"margin":{"type":["boolean"],"description":"<p>Distance between label and axis.</p>\n","default":3},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"padding":{"type":["string","Array"],"description":"\n\n<p>axisPointer space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":"[5, 7, 5, 7]"},"backgroundColor":{"type":["string"],"description":"<p>Background color of label, the same as <a href=\"#xAxis.axisLine.lineStyle.color\">axis.axisLine.lineStyle.color</a> by default.</p>\n","default":"'auto'"},"borderColor":{"type":["string"],"description":"<p>Border color of label.</p>\n","default":null},"borderWidth":{"type":["string"],"description":"<p>Border width of label.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"lineStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;line&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#555"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"shadowStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;shadow&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'rgba(150,150,150,0.3)"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"triggerTooltip":{"type":["boolean"],"description":"\n\n<p>Whether to trigger tooltip.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"value":{"type":["number"],"description":"<p>current value. When using <a href=\"xAxisPointer.handle\" target=\"_blank\">axisPointer.handle</a>, <code class=\"codespan\">value</code> can be set to define the initail position of axisPointer.</p>\n","default":null},"status":{"type":["boolean"],"description":"\n\n<p>Current status, can be <code class=\"codespan\">&#39;show&#39;</code> 和 <code class=\"codespan\">&#39;hide&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"show,hide"}},"handle":{"type":["Object"],"description":"<p>A button used to drag axisPointer. This feature is applicable in touch device. See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-tooltip-touch&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set to <code class=\"codespan\">true</code> to use handle.</p>\n","uiControl":{"type":"boolean"},"default":false},"icon":{"type":["*"],"description":"\n\n<p>The icon of the handle.</p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/axisPointer-handle-image&amp;edit=1&amp;reset=1\" target=\"_blank\">example of using image</a></p>\n","uiControl":{"type":"icon","clean":"true"}},"size":{"type":["number","Array"],"description":"\n\n<p>The size of the handle, which can be set as a single value or an array (<code class=\"codespan\">[width, height]</code>).</p>\n","uiControl":{"type":"vector","default":"45,45","min":"0","step":"0.5","dims":"width,height"},"default":45},"margin":{"type":["number"],"description":"\n\n<p>Distance from handle center to axis.</p>\n","uiControl":{"type":"number","default":"50","min":"0","step":"0.5"},"default":50},"color":{"type":["string"],"description":"\n\n<p>The color of the handle.</p>\n","uiControl":{"type":"color"},"default":"'#333'"},"throttle":{"type":["number"],"description":"\n\n<p>Throttle rate of trigger view update when dragging handle, in ms. Increase the value to improve performance, but decrease the experience.</p>\n","uiControl":{"type":"number","default":"40","min":"0","step":"10"},"default":40},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"2","step":"0.5"},"default":2},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"link":{"type":["Array"],"description":"<p>axisPointers can be linked to each other. The term &quot;link&quot; represents that axes are synchronized and move together. Axes are linked according to the value of axisPointer.</p>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=candlestick-brush&amp;edit=1&amp;reset=1\" target=\"_blank\">sampleA</a> and <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-nutrients-matrix&amp;edit=1&amp;reset=1\" target=\"_blank\">sampleB</a>.</p>\n<p>link is an array, where each item represents a &quot;link group&quot;. Axes will be linked when they are refered in the same link group. For example:</p>\n<pre><code class=\"lang-js\">link: [\n    {\n        // All axes with xAxisIndex 0, 3, 4 and yAxisName &#39;sameName&#39; will be linked.\n        xAxisIndex: [0, 3, 4],\n        yAxisName: &#39;someName&#39;\n    },\n    {\n        // All axes with xAxisId &#39;aa&#39;, &#39;cc&#39; and all angleAxis will be linked.\n        xAxisId: [&#39;aa&#39;, &#39;cc&#39;],\n        angleAxis: &#39;all&#39;\n    },\n    ...\n]\n</code></pre>\n<p>As illustrated above, axes can be refered in these approaches in a link group:</p>\n<pre><code class=\"lang-js\">{\n    // &#39;some&#39; represent the dimension name of a axis, namely, &#39;x&#39;, &#39;y&#39;, &#39;radius&#39;, &#39;angle&#39;, &#39;single&#39;\n    someAxisIndex: [...], // can be an array or a value or &#39;all&#39;\n    someAxisName: [...],  // can be an array or a value or &#39;all&#39;\n    someAxisId: [...],    // can be an array or a value or &#39;all&#39;\n}\n</code></pre>\n<hr>\n<hr>\n<p><strong>How to link axes with different <a href=\"#xAxis.type\">axis.type</a>?</strong></p>\n<p>For example, the type of axisA is &#39;category&#39;, and the type of axisB type is &#39;time&#39;, we can write conversion function (mapper) in link group to convert values from an axis to another axis. For example:</p>\n<pre><code class=\"lang-js\">link: [{\n    xAxisIndex: [0, 1],\n    yAxisName: [&#39;yy&#39;],\n    mapper: function (sourceVal, sourceAxisInfo, targetAxisInfo) {\n        if (sourceAxisInfo.axisName === &#39;yy&#39;) {\n            // from timestamp to &#39;2012-02-05&#39;\n            return echarts.format.formatTime(&#39;yyyy-MM-dd&#39;, sourceVal);\n        }\n        else if (targetAxisInfo.axisName === &#39;yy&#39;) {\n            // from &#39;2012-02-05&#39; to date\n            return echarts.number.parseDate(dates[sourceVal]);\n        }\n        else {\n            return sourceVal;\n        }\n    }\n}]\n</code></pre>\n<p>Input parameters of mapper:</p>\n<p><code class=\"codespan\">{number}</code> sourceVal</p>\n<p><code class=\"codespan\">{Object}</code> sourceAxisInfo Including {axisDim, axisId, axisName, axisIndex, ...}</p>\n<p><code class=\"codespan\">{Object}</code> targetAxisInfo Including {axisDim, axisId, axisName, axisIndex, ...}</p>\n<p>Return of mapper:</p>\n<p><code class=\"codespan\">{number}</code> The result of conversion.</p>\n"},"triggerOn":{"type":["string"],"description":"\n\n<p>Conditions to trigger tooltip. Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;mousemove&#39;</code></p>\n<p>  Trigger when mouse moves.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;click&#39;</code></p>\n<p>  Trigger when mouse clicks.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;mousemove|click&#39;</code></p>\n<p>  Trigger when mouse clicks and moves.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code></p>\n<p>  Do not triggered by <code class=\"codespan\">&#39;mousemove&#39;</code> and <code class=\"codespan\">&#39;click&#39;</code></p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"mousemove,click,none"},"default":"'mousemove|click'"}}},"toolbox":{"type":["Object"],"description":"<p>A group of utility tools, which includes <a href=\"#toolbox.feature.saveAsImage\">export</a>, <a href=\"#toolbox.feature.dataView\">data view</a>, <a href=\"#toolbox.feature.magicType\">dynamic type switching</a>, <a href=\"#toolbox.feature.dataZoom\">data area zooming</a>, and <a href=\"#toolbox.feature.reset\">reset</a>.</p>\n<p><strong>Example: </strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-marker&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n\n\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show toolbox component.</p>\n","uiControl":{"type":"boolean"},"default":true},"orient":{"type":["string"],"description":"\n\n<p>The layout orientation of toolbox&#39;s icon.</p>\n<p>Options:</p>\n<ul>\n<li>&#39;horizontal&#39;</li>\n<li>&#39;vertical&#39;</li>\n</ul>\n","uiControl":{"type":"enum","options":"vertical,horizontal"},"default":"'horizontal'"},"itemSize":{"type":["number"],"description":"\n\n<p>The size of toolbox&#39;s icon.</p>\n","uiControl":{"type":"number","min":"0","default":"15"},"default":15},"itemGap":{"type":["number"],"description":"\n\n<p>The gap between each icon of toolbox. It is horizontal gap in horizontal layout, while vertical gap in vertical layout.</p>\n","uiControl":{"type":"number","min":"0","default":"10"},"default":10},"showTitle":{"type":["boolean"],"description":"\n\n<p>Whether to show the title of each tool icon when mouse hovers.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"feature":{"type":["Object"],"description":"<p>The configuration item for each tool.</p>\n<p>Besides the tools we provide, user-defined toolbox is also supported.</p>\n<p>Notes: User-defined tool name could only start with <code class=\"codespan\">my</code>, like <code class=\"codespan\">myTool1</code> and <code class=\"codespan\">myTool2</code> in the below example:</p>\n<pre><code class=\"lang-javascript\">{\n    toolbox: {\n        feature: {\n            myTool1: {\n                show: true,\n                title: &#39;custom extension method 1&#39;,\n                icon: &#39;path://M432.45,595.444c0,2.177-4.661,6.82-11.305,6.82c-6.475,0-11.306-4.567-11.306-6.82s4.852-6.812,11.306-6.812C427.841,588.632,432.452,593.191,432.45,595.444L432.45,595.444z M421.155,589.876c-3.009,0-5.448,2.495-5.448,5.572s2.439,5.572,5.448,5.572c3.01,0,5.449-2.495,5.449-5.572C426.604,592.371,424.165,589.876,421.155,589.876L421.155,589.876z M421.146,591.891c-1.916,0-3.47,1.589-3.47,3.549c0,1.959,1.554,3.548,3.47,3.548s3.469-1.589,3.469-3.548C424.614,593.479,423.062,591.891,421.146,591.891L421.146,591.891zM421.146,591.891&#39;,\n                onclick: function (){\n                    alert(&#39;myToolHandler1&#39;)\n                }\n            },\n            myTool2: {\n                show: true,\n                title: &#39;custom extension method&#39;,\n                icon: &#39;image://http://echarts.baidu.com/images/favicon.png&#39;,\n                onclick: function (){\n                    alert(&#39;myToolHandler2&#39;)\n                }\n            }\n        }\n    }\n}\n</code></pre>\n","properties":{"saveAsImage":{"type":["Object"],"description":"<p>Save as image.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>File suffix of the image saved.</p>\n<ul>\n<li>If the <code class=\"codespan\">renderer</code> is set to be <code class=\"codespan\">&#39;canvas&#39;</code> when chart <a href=\"api.html#echarts.init\" target=\"_blank\">initialized</a> (default), then <code class=\"codespan\">&#39;png&#39;</code> (default) and <code class=\"codespan\">&#39;jpg&#39;</code> are supported.</li>\n<li>If the <code class=\"codespan\">renderer</code> is set to be <code class=\"codespan\">&#39;svg&#39;</code> when when chart <a href=\"api.html#echarts.init\" target=\"_blank\">initialized</a>, then only <code class=\"codespan\">&#39;svg&#39;</code> is supported for <code class=\"codespan\">type</code> (<code class=\"codespan\">&#39;svg&#39;</code> type is supported since <code class=\"codespan\">v4.8.0</code>).</li>\n</ul>\n","uiControl":{"type":"enum","options":"png,jpg"},"default":"'png'"},"name":{"type":["string"],"description":"\n\n<p>Name to save the image, whose default value is <a href=\"#title.text\">title.text</a>.</p>\n","uiControl":{"type":"text"}},"backgroundColor":{"type":["Color"],"description":"\n\n<p>Background color to save the image, whose default value is <a href=\"#backgroundColor\">backgroundColor</a>. If <code class=\"codespan\">backgroundColor</code> is not set, white color is used.</p>\n","uiControl":{"type":"color"},"default":"'auto'"},"connectedBackgroundColor":{"type":["Color"],"description":"\n\n<p>When <a href=\"api.html#echarts.connect\" target=\"_blank\">echarts.connect</a> is used to connect the interaction of multiple chart series, they will all be included in the exported image. This option sets the background color between these charts.</p>\n","uiControl":{"type":"color"},"default":"'#fff'"},"excludeComponents":{"type":["Array"],"description":"<p>Components to be excluded when export. By default, toolbox is excluded.</p>\n","default":"['toolbox']"},"show":{"type":["boolean"],"description":"<p>Whether to show the tool.</p>\n","default":true},"title":{"type":["string"],"description":"","default":"'save as image'"},"icon":{"type":["*"],"description":"<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"iconStyle":{"type":["Object"],"description":"<p>The style setting of save as image icon. Since icon label is displayed only when hovering on the icon, the label configuration options are available under <code class=\"codespan\">emphasis</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"none"},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"#666"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"","properties":{"iconStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"textPosition":{"type":["string"],"description":"<p>Text position: <code class=\"codespan\">&#39;left&#39;</code> / <code class=\"codespan\">&#39;right&#39;</code> / <code class=\"codespan\">&#39;top&#39;</code> / <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n","default":"'bottom'"},"textFill":{"type":["string"],"description":"\n\n<p>Fill color of text. If it&#39;s not set, it will use in the order of icon&#39;s fill color, stroke color, and <code class=\"codespan\">&#39;#000&#39;</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"textAlign":{"type":["string"],"description":"\n\n<p>Text align: <code class=\"codespan\">&#39;left&#39;</code> / <code class=\"codespan\">&#39;center&#39;</code> / <code class=\"codespan\">&#39;right&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"left,center,right"},"default":"'center'"},"textBackgroundColor":{"type":["string"],"description":"\n\n<p>Text background color.</p>\n","uiControl":{"type":"color"}},"textBorderRadius":{"type":["number"],"description":"\n\n<p>Border radius of text area.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"}},"textPadding":{"type":["number"],"description":"\n\n<p>Padding of text area.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"}}}}}},"pixelRatio":{"type":["number"],"description":"\n\n<p>Resolution ratio to save image, whose default value is that of the container. Values larger than 1 (e.g.: 2) is supported when you need higher resolution.</p>\n","uiControl":{"type":"number","min":"0.5","max":"5","step":"0.5"},"default":1}}},"restore":{"type":["Object"],"description":"<p>Restore configuration item.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show the tool.</p>\n","default":true},"title":{"type":["string"],"description":"","default":"'restore'"},"icon":{"type":["*"],"description":"<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"iconStyle":{"type":["Object"],"description":"<p>The style setting of restore icon. Since icon label is displayed only when hovering on the icon, the label configuration options are available under <code class=\"codespan\">emphasis</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"none"},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"#666"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"","properties":{"iconStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"textPosition":{"type":["string"],"description":"<p>Text position: <code class=\"codespan\">&#39;left&#39;</code> / <code class=\"codespan\">&#39;right&#39;</code> / <code class=\"codespan\">&#39;top&#39;</code> / <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n","default":"'bottom'"},"textFill":{"type":["string"],"description":"\n\n<p>Fill color of text. If it&#39;s not set, it will use in the order of icon&#39;s fill color, stroke color, and <code class=\"codespan\">&#39;#000&#39;</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"textAlign":{"type":["string"],"description":"\n\n<p>Text align: <code class=\"codespan\">&#39;left&#39;</code> / <code class=\"codespan\">&#39;center&#39;</code> / <code class=\"codespan\">&#39;right&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"left,center,right"},"default":"'center'"},"textBackgroundColor":{"type":["string"],"description":"\n\n<p>Text background color.</p>\n","uiControl":{"type":"color"}},"textBorderRadius":{"type":["number"],"description":"\n\n<p>Border radius of text area.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"}},"textPadding":{"type":["number"],"description":"\n\n<p>Padding of text area.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"}}}}}}}},"dataView":{"type":["Object"],"description":"<p>Data view tool, which could display data in current chart and updates chart after being edited.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show the tool.</p>\n","default":true},"title":{"type":["string"],"description":"","default":"'data view'"},"icon":{"type":["*"],"description":"<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"iconStyle":{"type":["Object"],"description":"<p>The style setting of data view icon. Since icon label is displayed only when hovering on the icon, the label configuration options are available under <code class=\"codespan\">emphasis</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"none"},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"#666"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"","properties":{"iconStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"textPosition":{"type":["string"],"description":"<p>Text position: <code class=\"codespan\">&#39;left&#39;</code> / <code class=\"codespan\">&#39;right&#39;</code> / <code class=\"codespan\">&#39;top&#39;</code> / <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n","default":"'bottom'"},"textFill":{"type":["string"],"description":"\n\n<p>Fill color of text. If it&#39;s not set, it will use in the order of icon&#39;s fill color, stroke color, and <code class=\"codespan\">&#39;#000&#39;</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"textAlign":{"type":["string"],"description":"\n\n<p>Text align: <code class=\"codespan\">&#39;left&#39;</code> / <code class=\"codespan\">&#39;center&#39;</code> / <code class=\"codespan\">&#39;right&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"left,center,right"},"default":"'center'"},"textBackgroundColor":{"type":["string"],"description":"\n\n<p>Text background color.</p>\n","uiControl":{"type":"color"}},"textBorderRadius":{"type":["number"],"description":"\n\n<p>Border radius of text area.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"}},"textPadding":{"type":["number"],"description":"\n\n<p>Padding of text area.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"}}}}}},"readOnly":{"type":["boolean"],"description":"\n\n<p>Whether it is read-only.</p>\n","uiControl":{"type":"boolean"},"default":false},"optionToContent":{"type":["Function"],"description":"<pre><code class=\"lang-js\">(option:Object) =&gt; HTMLDomElement|string\n</code></pre>\n<p>Define a function to present dataView. It is used to replace default textarea for richer data editing. It can return a DOM object, or an HTML string.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">optionToContent: function(opt) {\n    var axisData = opt.xAxis[0].data;\n    var series = opt.series;\n    var table = &#39;&lt;table style=&quot;width:100%;text-align:center&quot;&gt;&lt;tbody&gt;&lt;tr&gt;&#39;\n                 + &#39;&lt;td&gt;Time:&lt;/td&gt;&#39;\n                 + &#39;&lt;td&gt;&#39; + series[0].name + &#39;&lt;/td&gt;&#39;\n                 + &#39;&lt;td&gt;&#39; + series[1].name + &#39;&lt;/td&gt;&#39;\n                 + &#39;&lt;/tr&gt;&#39;;\n    for (var i = 0, l = axisData.length; i &lt; l; i++) {\n        table += &#39;&lt;tr&gt;&#39;\n                 + &#39;&lt;td&gt;&#39; + axisData[i] + &#39;&lt;/td&gt;&#39;\n                 + &#39;&lt;td&gt;&#39; + series[0].data[i] + &#39;&lt;/td&gt;&#39;\n                 + &#39;&lt;td&gt;&#39; + series[1].data[i] + &#39;&lt;/td&gt;&#39;\n                 + &#39;&lt;/tr&gt;&#39;;\n    }\n    table += &#39;&lt;/tbody&gt;&lt;/table&gt;&#39;;\n    return table;\n}\n</code></pre>\n"},"contentToOption":{"type":["Function"],"description":"<pre><code class=\"lang-js\">(container:HTMLDomElement, option:Object) =&gt; Object\n</code></pre>\n<p>When optionToContent is used, if you want to support refreshing chart after data changes, you need to implement the logic to merge options in this function.</p>\n"},"lang":{"type":["Array"],"description":"<p>There are 3 names in data view, which are <code class=\"codespan\">[&#39;data view&#39;, &#39;turn off&#39; and &#39;refresh&#39;]</code>.</p>\n","default":"['data view', 'turn off', 'refresh']"},"backgroundColor":{"type":["string"],"description":"\n\n<p>Background color of the floating layer in data view.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'#fff'"},"textareaColor":{"type":["string"],"description":"\n\n<p>Background color of input area of the floating layer in data view.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'#fff'"},"textareaBorderColor":{"type":["string"],"description":"\n\n<p>Border color of input area of the floating layer in data view.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"textColor":{"type":["string"],"description":"\n\n<p>Text color.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'#000'"},"buttonColor":{"type":["string"],"description":"\n\n<p>Button color.</p>\n","uiControl":{"type":"color","default":"#c23531"},"default":"'#c23531'"},"buttonTextColor":{"type":["string"],"description":"\n\n<p>Color of button text.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'#fff'"}}},"dataZoom":{"type":["Object"],"description":"<p>Data area zooming, which only supports rectangular coordinate by now.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show the tool.</p>\n","default":true},"title":{"type":["Object"],"description":"<p>Restored and zoomed title text.</p>\n","properties":{"zoom":{"type":["string"],"description":"","default":"'area zooming'"},"back":{"type":["string"],"description":"","default":"'restore area zooming'"}}},"icon":{"type":["Object"],"description":"<p>Zooming and restore icon path.</p>\n","properties":{"zoom":{"type":["string"],"description":"<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"back":{"type":["string"],"description":"<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"}}},"iconStyle":{"type":["Object"],"description":"<p>The style setting of data area zooming icon. Since icon label is displayed only when hovering on the icon, the label configuration options are available under <code class=\"codespan\">emphasis</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"none"},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"#666"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"","properties":{"iconStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"textPosition":{"type":["string"],"description":"<p>Text position: <code class=\"codespan\">&#39;left&#39;</code> / <code class=\"codespan\">&#39;right&#39;</code> / <code class=\"codespan\">&#39;top&#39;</code> / <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n","default":"'bottom'"},"textFill":{"type":["string"],"description":"\n\n<p>Fill color of text. If it&#39;s not set, it will use in the order of icon&#39;s fill color, stroke color, and <code class=\"codespan\">&#39;#000&#39;</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"textAlign":{"type":["string"],"description":"\n\n<p>Text align: <code class=\"codespan\">&#39;left&#39;</code> / <code class=\"codespan\">&#39;center&#39;</code> / <code class=\"codespan\">&#39;right&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"left,center,right"},"default":"'center'"},"textBackgroundColor":{"type":["string"],"description":"\n\n<p>Text background color.</p>\n","uiControl":{"type":"color"}},"textBorderRadius":{"type":["number"],"description":"\n\n<p>Border radius of text area.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"}},"textPadding":{"type":["number"],"description":"\n\n<p>Padding of text area.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"}}}}}},"filterMode":{"type":["string"],"description":"<p>The same meaning as <a href=\"#dataZoom.filterMode\">dataZoom.filterMode</a>.</p>\n","default":"'filter'"},"xAxisIndex":{"type":["number","Array","boolean"],"description":"<p>Defines which <a href=\"#xAxis\">xAxis</a> should be controlled. By default, it controls all x axes. If it is set to be <code class=\"codespan\">false</code>, then no x axis is controlled. If it is set to be then it controls axis with axisIndex of <code class=\"codespan\">3</code>. If it is set to be <code class=\"codespan\">[0, 3]</code>, it controls the x-axes with axisIndex of <code class=\"codespan\">0</code> and <code class=\"codespan\">3</code>.</p>\n"},"yAxisIndex":{"type":["number","Array","boolean"],"description":"<p>Defines which <a href=\"#yAxis\">yAxis</a> should be controlled. By default, it controls all y axes. If it is set to be <code class=\"codespan\">false</code>, then no y axis is controlled. If it is set to be then it controls axis with axisIndex of <code class=\"codespan\">3</code>. If it is set to be <code class=\"codespan\">[0, 3]</code>, it controls the x-axes with axisIndex of <code class=\"codespan\">0</code> and <code class=\"codespan\">3</code>.</p>\n"},"brushStyle":{"type":["Object"],"description":"<p>Style of brush rectangle.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"magicType":{"type":["Object"],"description":"<p>Magic type switching.\n<strong>示例: </strong></p>\n<pre><code class=\"lang-js\">feature: {\n    magicType: {\n        type: [&#39;line&#39;, &#39;bar&#39;, &#39;stack&#39;, &#39;tiled&#39;]\n    }\n}\n</code></pre>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show the tool.</p>\n","default":true},"type":{"type":["Array"],"description":"<p>Enabled magic types, including <code class=\"codespan\">&#39;line&#39;</code> (for line charts), <code class=\"codespan\">&#39;bar&#39;</code> (for bar charts), <code class=\"codespan\">&#39;stack&#39;</code> (for stacked charts), and <code class=\"codespan\">&#39;tiled&#39;</code> (for tiled charts).</p>\n"},"title":{"type":["Object"],"description":"<p>Title for different types, can be configured seperately.</p>\n","properties":{"line":{"type":["string"],"description":"","default":"'for line charts'"},"bar":{"type":["string"],"description":"","default":"'for bar charts'"},"stack":{"type":["string"],"description":"","default":"'for stacked charts'"},"tiled":{"type":["string"],"description":"","default":"'for tiled charts'"}}},"icon":{"type":["Object"],"description":"<p>the different types of icon path , which could be configurated individually.</p>\n","properties":{"line":{"type":["string"],"description":"<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"bar":{"type":["string"],"description":"<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"stack":{"type":["string"],"description":"<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"tiled":{"type":["string"],"description":"<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"}}},"iconStyle":{"type":["Object"],"description":"<p>The style setting of magic type switching icon. Since icon label is displayed only when hovering on the icon, the label configuration options are available under <code class=\"codespan\">emphasis</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"none"},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"#666"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"","properties":{"iconStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"textPosition":{"type":["string"],"description":"<p>Text position: <code class=\"codespan\">&#39;left&#39;</code> / <code class=\"codespan\">&#39;right&#39;</code> / <code class=\"codespan\">&#39;top&#39;</code> / <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n","default":"'bottom'"},"textFill":{"type":["string"],"description":"\n\n<p>Fill color of text. If it&#39;s not set, it will use in the order of icon&#39;s fill color, stroke color, and <code class=\"codespan\">&#39;#000&#39;</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"textAlign":{"type":["string"],"description":"\n\n<p>Text align: <code class=\"codespan\">&#39;left&#39;</code> / <code class=\"codespan\">&#39;center&#39;</code> / <code class=\"codespan\">&#39;right&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"left,center,right"},"default":"'center'"},"textBackgroundColor":{"type":["string"],"description":"\n\n<p>Text background color.</p>\n","uiControl":{"type":"color"}},"textBorderRadius":{"type":["number"],"description":"\n\n<p>Border radius of text area.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"}},"textPadding":{"type":["number"],"description":"\n\n<p>Padding of text area.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"}}}}}},"option":{"type":["Object"],"description":"<p>Configuration item for each type, which will be used when switching to certain type.</p>\n","properties":{"line":{"type":["Object"],"description":""},"bar":{"type":["Object"],"description":""},"stack":{"type":["Object"],"description":""},"tiled":{"type":["Object"],"description":""}}},"seriesIndex":{"type":["Object"],"description":"<p>Series list for each type.</p>\n","properties":{"line":{"type":["Array"],"description":""},"bar":{"type":["Array"],"description":""},"stack":{"type":["Array"],"description":""},"tiled":{"type":["Array"],"description":""}}}}},"brush":{"type":["Object"],"description":"<p>Brush-selecting icon.</p>\n<p>It can also be configured at <a href=\"#brush.toolbox\">brush.toolbox</a>.</p>\n","properties":{"type":{"type":["Array"],"description":"<p>Icons used, whose values are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;rect&#39;</code>: Enabling selecting with rectangle area.</li>\n<li><code class=\"codespan\">&#39;polygon&#39;</code>: Enabling selecting with any shape.</li>\n<li><code class=\"codespan\">&#39;lineX&#39;</code>: Enabling horizontal selecting.</li>\n<li><code class=\"codespan\">&#39;lineY&#39;</code>: Enabling vertical selecting.</li>\n<li><code class=\"codespan\">&#39;keep&#39;</code>: Switching between <em>single selecting</em> and <em>multiple selecting</em>. The latter one can select multiple areas, while the former one cancels previous selection.</li>\n<li><code class=\"codespan\">&#39;clear&#39;</code>: Clearing all selection.</li>\n</ul>\n"},"icon":{"type":["Object"],"description":"<p>Icon path for each icon.</p>\n","properties":{"rect":{"type":["string"],"description":"<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"polygon":{"type":["string"],"description":"<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"lineX":{"type":["string"],"description":"<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"lineY":{"type":["string"],"description":"<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"keep":{"type":["string"],"description":"<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"clear":{"type":["string"],"description":"<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"}}},"title":{"type":["Object"],"description":"<p>Title.</p>\n","properties":{"rect":{"type":["string"],"description":"","default":"'Rectangle selection'"},"polygon":{"type":["string"],"description":"","default":"'Polygon selection'"},"lineX":{"type":["string"],"description":"","default":"'Horizontal selection'"},"lineY":{"type":["string"],"description":"","default":"'Vertical selection'"},"keep":{"type":["string"],"description":"","default":"'Keep previous selection'"},"clear":{"type":["string"],"description":"","default":"'Clear selection'"}}}}}}},"iconStyle":{"type":["Object"],"description":"<p>The style setting of Shared icon. Since icon label is displayed only when hovering on the icon, the label configuration options are available under <code class=\"codespan\">emphasis</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"none"},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"#666"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"","properties":{"iconStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"textPosition":{"type":["string"],"description":"<p>Text position: <code class=\"codespan\">&#39;left&#39;</code> / <code class=\"codespan\">&#39;right&#39;</code> / <code class=\"codespan\">&#39;top&#39;</code> / <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n","default":"'bottom'"},"textFill":{"type":["string"],"description":"\n\n<p>Fill color of text. If it&#39;s not set, it will use in the order of icon&#39;s fill color, stroke color, and <code class=\"codespan\">&#39;#000&#39;</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"textAlign":{"type":["string"],"description":"\n\n<p>Text align: <code class=\"codespan\">&#39;left&#39;</code> / <code class=\"codespan\">&#39;center&#39;</code> / <code class=\"codespan\">&#39;right&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"left,center,right"},"default":"'center'"},"textBackgroundColor":{"type":["string"],"description":"\n\n<p>Text background color.</p>\n","uiControl":{"type":"color"}},"textBorderRadius":{"type":["number"],"description":"\n\n<p>Border radius of text area.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"}},"textPadding":{"type":["number"],"description":"\n\n<p>Padding of text area.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"}}}}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between toolbox component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'auto'"},"top":{"type":["string","number"],"description":"<p>Distance between toolbox component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'auto'"},"right":{"type":["string","number"],"description":"<p>Distance between toolbox component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"bottom":{"type":["string","number"],"description":"<p>Distance between toolbox component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"width":{"type":["string","number"],"description":"<p>Width of toolbox component. Adaptive by default.</p>\n","default":"'auto'"},"height":{"type":["string","number"],"description":"<p>Height of toolbox component. Adaptive by default.</p>\n","default":"'auto'"},"tooltip":{"type":["Object"],"description":"<p>Tooltip configuration for toolbox tooltip, which is similar to <a href=\"#tooltip\">tooltip</a>. It is not shown by default. If you wish to set special style for toolbox icon label (especially when using CSS to control text style), you may set as the following example:</p>\n<pre><code class=\"lang-js\">option = {\n    tooltip: {\n        show: true // include tooltip component for the feature\n    },\n    toolbox: {\n        show: true,\n        showTitle: false, // hide the default text so they don&#39;t overlap each other\n        feature: {\n            saveAsImage: {\n                show: true,\n                title: &#39;Save As Image&#39;\n            },\n            dataView: {\n                show: true,\n                title: &#39;Data View&#39;\n            },\n        },\n        tooltip: { // same as option.tooltip\n            show: true,\n            formatter: function (param) {\n                return return &#39;&lt;div&gt;&#39; + param.title + &#39;&lt;/div&gt;&#39;; // user-defined DOM structure\n            },\n            backgroundColor: &#39;#222&#39;,\n            textStyle: {\n                fontSize: 12,\n            },\n            extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39; // user-defined CSS styles\n        }\n    },\n    ...\n}\n</code></pre>\n"}}},"brush":{"type":["Object"],"description":"<p><code class=\"codespan\">brush</code> is an area-selecting component, with which user can select part of data from a chart to display in detail, or do calculations with them.</p>\n<p><br></p>\n<hr>\n<p><strong>Brush type and triggering button</strong></p>\n<p>Currently, supported <code class=\"codespan\">brush</code> types include: <code class=\"codespan\">scatter</code>, <code class=\"codespan\">bar</code>, <code class=\"codespan\">candlestick</code>. (Note that <code class=\"codespan\">parallel</code> contains brush function by itself, which is not provided by brush component.)</p>\n<p>Click the button in <code class=\"codespan\">toolbox</code> to enable operations like <em>area selecting</em>, or <em>canceling selecting</em>.</p>\n<p><br>\nExample of <code class=\"codespan\">horizontal brush</code>: (Click the button in <code class=\"codespan\">toolbox</code> to enable brushing.)</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=candlestick-brush&edit=1&reset=1\" width=\"800\" height=\"500\"></iframe>\n\n\n<p><br>\nExample of <code class=\"codespan\">brush</code> in <code class=\"codespan\">bar</code> charts:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-brush&edit=1&reset=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n<p>Button for <code class=\"codespan\">brush</code> can be assigned in <a href=\"#toolbox.feature.brush.type\"><code class=\"codespan\">toolbox</code></a> or <a href=\"#brush.toolbox\"><code class=\"codespan\">brush</code> configuration</a>.</p>\n<p>The following types of brushes are supported: <code class=\"codespan\">rect</code>, <code class=\"codespan\">polygon</code>, <code class=\"codespan\">lineX</code>, <code class=\"codespan\">lineY</code>. See <a href=\"#brush.toolbox\">brush.toolbox</a> for more information.</p>\n<p><code class=\"codespan\">keep</code> button can be used to toggle a single or multiple selections.</p>\n<ul>\n<li>Only one select box is available in single selection mode, and the select-box can be removed by clicking on the blank area.</li>\n<li>Multiple select boxes are available in multiple selection mode, and the select-boxes cannot be removed by click on the blank area. Instead, you need to click the <em>clear</em> button.</li>\n</ul>\n<p><br></p>\n<hr>\n<p><strong>Relationship between brush-selecting and coordinates</strong></p>\n<p><code class=\"codespan\">brush</code> can be set to be <em>global</em>, or <em>belonging to a particular coordinate</em>.</p>\n<p><strong>Global brushes</strong></p>\n<p>Selecting is enabled for everywhere in ECharts&#39;s instance in this case. This is the default situation, when brush is not set to be global.</p>\n<p><strong>Coordinate brushes</strong></p>\n<p>Selecting is enabled only in the assigned coordinates in this case. Selecting-box will be altered according to scaling and translating of coordinate (see <code class=\"codespan\">roam</code> and <code class=\"codespan\">dataZoom</code>).</p>\n<p>In practice, you may often find coordinate brush to be a more frequently made choice, particularly in <code class=\"codespan\">geo</code> charts.</p>\n<p>By assigning <a href=\"#brush.geoIndex\">brush.geoIndex</a>, or <a href=\"#brush.xAxisIndex\">brush.xAxisIndex</a>, or <a href=\"#brush.yAxisIndex\">brush.yAxisIndex</a>, brush selecting axes can be assigned, whose value can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;all&#39;</code>: for all axes;</li>\n<li><code class=\"codespan\">number</code>: like <code class=\"codespan\">0</code>, for a particular coordinate with that index;</li>\n<li><code class=\"codespan\">Array</code>: like <code class=\"codespan\">[0, 4, 2]</code>, for coordinates with those indexes;</li>\n<li><code class=\"codespan\">&#39;none&#39;</code>, or <code class=\"codespan\">null</code>, or <code class=\"codespan\">undefined</code>: for not assigning.</li>\n</ul>\n<p>Example:</p>\n<pre><code class=\"lang-javascript\">option = {\n    geo: {\n        ...\n    },\n    brush: {\n        geoIndex: &#39;all&#39;, // brush selecting is enabled only in all geo charts above\n        ...\n    }\n};\n</code></pre>\n<p>Example:</p>\n<pre><code class=\"lang-javascript\">option = {\n    grid: [\n        {...}, // grid 0\n        {...}  // grid 1\n    ],\n    xAxis: [\n        {gridIndex: 1, ...}, // xAxis 0 for grid 1\n        {gridIndex: 0, ...}  // xAxis 1 for grid 0\n    ],\n    yAxis: [\n        {gridIndex: 1, ...}, // yAxis 0 for grid 1\n        {gridIndex: 0, ...}  // yAxis 1 for grid 0\n    ],\n    brush: {\n        xAxisIndex: [0, 1], // brush selecting is enabled only in coordinates with xAxisIndex as `0` or `1`\n        ...\n    }\n};\n</code></pre>\n<p><br></p>\n<hr>\n<p><strong>Control select-box with API</strong></p>\n<p><code class=\"codespan\">dispatchAction</code> can be used to render select-box programatically. For example:</p>\n<pre><code class=\"lang-javascript\">myChart.dispatchAction({\n    type: &#39;brush&#39;,\n    areas: [\n        {\n            geoIndex: 0,\n            // Assign select-box type\n            brushType: &#39;polygon&#39;,\n            // Assign select-box shape\n            coordRange: [[119.72,34.85],[119.68,34.85],[119.5,34.84],[119.19,34.77]]\n        }\n    ]\n});\n</code></pre>\n<p>Please refer to <a href=\"api.html#action.brush\" target=\"_blank\">action.brush</a> for more information.</p>\n<p><br></p>\n<hr>\n<p><strong>brushLink</strong></p>\n<p>Links interaction between selected items in different series.</p>\n<p>Following is an example of enabling selected effect for <code class=\"codespan\">scatter</code> and <code class=\"codespan\">parallel</code> charts once a scatter chart is selected.</p>\n<p><code class=\"codespan\">brushLink</code> is an array of <code class=\"codespan\">seriesIndex</code>es, which assignes the series that can be interacted. For example, it can be:</p>\n<ul>\n<li><code class=\"codespan\">[3, 4, 5]</code> for interacting series with seriesIndex as <code class=\"codespan\">3</code>, <code class=\"codespan\">4</code>, or <code class=\"codespan\">5</code>;</li>\n<li><code class=\"codespan\">&#39;all&#39;</code> for interacting all series;</li>\n<li><code class=\"codespan\">&#39;none&#39;</code>, or <code class=\"codespan\">null</code>, or <code class=\"codespan\">undefined</code> for disabling <code class=\"codespan\">brushLink</code>.</li>\n</ul>\n<p><strong>Attention</strong></p>\n<p><code class=\"codespan\">brushLink</code> is a mapping of <code class=\"codespan\">dataIndex</code>. So <strong><code class=\"codespan\">data</code> of every series with <code class=\"codespan\">brushLink</code> should be guaranteed to correspond to the other</strong>.</p>\n<p>Example:</p>\n<pre><code class=\"lang-javascript\">option = {\n    brush: {\n        brushLink: [0, 1]\n    },\n    series: [\n        {\n            type: &#39;bar&#39;\n            data: [232,    4434,    545,      654]     // data has 4 items\n        },\n        {\n            type: &#39;parallel&#39;,\n            data: [[4, 5], [3, 5], [66, 33], [99, 66]] // data also has 4 items, which correspond to the data above\n        }\n    ]\n};\n</code></pre>\n<p>Please refer to <a href=\"#brush.brushLink\">brush.brushLink</a>.</p>\n<p><br></p>\n<hr>\n<p><strong>throttle / debounce</strong></p>\n<p>By default, <code class=\"codespan\">brushSelected</code> is always triggered when selection-box is selected or moved, to tell the outside about the event.</p>\n<p>But efficiency problems may occur when events are triggered too frequently, or the animation result may be affected. So brush components provides <a href=\"#brush.throttleType\">brush.throttleType</a> and <a href=\"#brush.throttleDelay\">brush.throttleDelay</a> to solve this problem.</p>\n<p>Valid <code class=\"codespan\">throttleType</code> values can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;debounce&#39;</code>: for triggering events only when the action has been stopped (no action after some duration). Time threshold can be assigned with <a href=\"#brush.throttleDelay\">brush.throttleDelay</a>;</li>\n<li><code class=\"codespan\">&#39;fixRate&#39;</code>: for triggering event with a certain frequency. The frequency can be assigned with <a href=\"#brush.throttleDelay\">brush.throttleDelay</a>.</li>\n</ul>\n<p>In this <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-map-brush&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>, <code class=\"codespan\">debounce</code> is used to make sure the bar chart is updated only when the user has stopped action. In other cases, the animation result may not be so good.</p>\n<p><br></p>\n<hr>\n<p><strong>Visual configurations of selected and unselected items</strong></p>\n<p>Refer to <a href=\"#brush.inBrush\">brush.inBrush</a> and <a href=\"#brush.outOfBrush\">brush.outOfBrush</a>.</p>\n<p><br></p>\n<hr>\n<p>Here is the configuration in detail.</p>\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"toolbox":{"type":["Array"],"description":"<p>Use the buttons in toolbox.</p>\n<p>Buttons in toolbox that is related to brush includes:</p>\n<ul>\n<li><code class=\"codespan\">&#39;rect&#39;</code>: for selection-box in rectangle shape;</li>\n<li><code class=\"codespan\">&#39;polygon&#39;</code>: for selection-box in polygon shape;</li>\n<li><code class=\"codespan\">&#39;lineX&#39;</code>: for horizontal selection-box;</li>\n<li><code class=\"codespan\">&#39;lineY&#39;</code>: for vertical selection-box;</li>\n<li><code class=\"codespan\">&#39;keep&#39;</code>: for setting mode between <code class=\"codespan\">single</code> and <code class=\"codespan\">multiple</code> selection, the former of which supports clearing selection on click, and the latter selecting multiple areas;</li>\n<li><code class=\"codespan\">&#39;clear&#39;</code>: for clearing all selections.</li>\n</ul>\n","default":"['rect', 'polygon', 'keep', 'clear']"},"brushLink":{"type":["Array","string"],"description":"<p>Links interaction between selected items in different series.</p>\n<p>Following is an example of enabling selected effect for <code class=\"codespan\">scatter</code> and <code class=\"codespan\">parallel</code> charts once a scatter chart is selected.</p>\n<p><code class=\"codespan\">brushLink</code> is an array of <code class=\"codespan\">seriesIndex</code>es, which assignes the series that can be interacted. For example, it can be:</p>\n<ul>\n<li><code class=\"codespan\">[3, 4, 5]</code> for interacting series with seriesIndex as <code class=\"codespan\">3</code>, <code class=\"codespan\">4</code>, or <code class=\"codespan\">5</code>;</li>\n<li><code class=\"codespan\">&#39;all&#39;</code> for interacting all series;</li>\n<li><code class=\"codespan\">&#39;none&#39;</code>, or <code class=\"codespan\">null</code>, or <code class=\"codespan\">undefined</code> for disabling <code class=\"codespan\">brushLink</code>.</li>\n</ul>\n<p><strong>Attention</strong></p>\n<p><code class=\"codespan\">brushLink</code> is a mapping of <code class=\"codespan\">dataIndex</code>. So <strong><code class=\"codespan\">data</code> of every series with <code class=\"codespan\">brushLink</code> should be guaranteed to correspond to the other</strong>.</p>\n<p>Example:</p>\n<pre><code class=\"lang-javascript\">option = {\n    brush: {\n        brushLink: [0, 1]\n    },\n    series: [\n        {\n            type: &#39;bar&#39;\n            data: [232,    4434,    545,      654]     // data has 4 items\n        },\n        {\n            type: &#39;parallel&#39;,\n            data: [[4, 5], [3, 5], [66, 33], [99, 66]] // data also has 4 items, which correspond to the data above\n        }\n    ]\n};\n</code></pre>\n","default":null},"seriesIndex":{"type":["Array","number","string"],"description":"<p>Assigns which of the series can use brush selecting, whose value can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;all&#39;</code>: all series;</li>\n<li><code class=\"codespan\">&#39;Array&#39;</code>: series index array;</li>\n<li><code class=\"codespan\">&#39;number&#39;</code>: certain series index.</li>\n</ul>\n","default":"'all'"},"geoIndex":{"type":["Array","number","string"],"description":"<p>Assigns which of the geo can use brush selecting.</p>\n<p><code class=\"codespan\">brush</code> can be set to be <em>global</em>, or <em>belonging to a particular coordinate</em>.</p>\n<p><strong>Global brushes</strong></p>\n<p>Selecting is enabled for everywhere in ECharts&#39;s instance in this case. This is the default situation, when brush is not set to be global.</p>\n<p><strong>Coordinate brushes</strong></p>\n<p>Selecting is enabled only in the assigned coordinates in this case. Selecting-box will be altered according to scaling and translating of coordinate (see <code class=\"codespan\">roam</code> and <code class=\"codespan\">dataZoom</code>).</p>\n<p>In practice, you may often find coordinate brush to be a more frequently made choice, particularly in <code class=\"codespan\">geo</code> charts.</p>\n<p>By assigning <a href=\"#brush.geoIndex\">brush.geoIndex</a>, or <a href=\"#brush.xAxisIndex\">brush.xAxisIndex</a>, or <a href=\"#brush.yAxisIndex\">brush.yAxisIndex</a>, brush selecting axes can be assigned, whose value can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;all&#39;</code>: for all axes;</li>\n<li><code class=\"codespan\">number</code>: like <code class=\"codespan\">0</code>, for a particular coordinate with that index;</li>\n<li><code class=\"codespan\">Array</code>: like <code class=\"codespan\">[0, 4, 2]</code>, for coordinates with those indexes;</li>\n<li><code class=\"codespan\">&#39;none&#39;</code>, or <code class=\"codespan\">null</code>, or <code class=\"codespan\">undefined</code>: for not assigning.</li>\n</ul>\n<p>Example:</p>\n<pre><code class=\"lang-javascript\">option = {\n    geo: {\n        ...\n    },\n    brush: {\n        geoIndex: &#39;all&#39;, // brush selecting is enabled only in all geo charts above\n        ...\n    }\n};\n</code></pre>\n<p>Example:</p>\n<pre><code class=\"lang-javascript\">option = {\n    grid: [\n        {...}, // grid 0\n        {...}  // grid 1\n    ],\n    xAxis: [\n        {gridIndex: 1, ...}, // xAxis 0 for grid 1\n        {gridIndex: 0, ...}  // xAxis 1 for grid 0\n    ],\n    yAxis: [\n        {gridIndex: 1, ...}, // yAxis 0 for grid 1\n        {gridIndex: 0, ...}  // yAxis 1 for grid 0\n    ],\n    brush: {\n        xAxisIndex: [0, 1], // brush selecting is enabled only in coordinates with xAxisIndex as `0` or `1`\n        ...\n    }\n};\n</code></pre>\n","default":null},"xAxisIndex":{"type":["Array","number","string"],"description":"<p>Assigns which of the xAxisIndex can use brush selecting.</p>\n<p><code class=\"codespan\">brush</code> can be set to be <em>global</em>, or <em>belonging to a particular coordinate</em>.</p>\n<p><strong>Global brushes</strong></p>\n<p>Selecting is enabled for everywhere in ECharts&#39;s instance in this case. This is the default situation, when brush is not set to be global.</p>\n<p><strong>Coordinate brushes</strong></p>\n<p>Selecting is enabled only in the assigned coordinates in this case. Selecting-box will be altered according to scaling and translating of coordinate (see <code class=\"codespan\">roam</code> and <code class=\"codespan\">dataZoom</code>).</p>\n<p>In practice, you may often find coordinate brush to be a more frequently made choice, particularly in <code class=\"codespan\">geo</code> charts.</p>\n<p>By assigning <a href=\"#brush.geoIndex\">brush.geoIndex</a>, or <a href=\"#brush.xAxisIndex\">brush.xAxisIndex</a>, or <a href=\"#brush.yAxisIndex\">brush.yAxisIndex</a>, brush selecting axes can be assigned, whose value can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;all&#39;</code>: for all axes;</li>\n<li><code class=\"codespan\">number</code>: like <code class=\"codespan\">0</code>, for a particular coordinate with that index;</li>\n<li><code class=\"codespan\">Array</code>: like <code class=\"codespan\">[0, 4, 2]</code>, for coordinates with those indexes;</li>\n<li><code class=\"codespan\">&#39;none&#39;</code>, or <code class=\"codespan\">null</code>, or <code class=\"codespan\">undefined</code>: for not assigning.</li>\n</ul>\n<p>Example:</p>\n<pre><code class=\"lang-javascript\">option = {\n    geo: {\n        ...\n    },\n    brush: {\n        geoIndex: &#39;all&#39;, // brush selecting is enabled only in all geo charts above\n        ...\n    }\n};\n</code></pre>\n<p>Example:</p>\n<pre><code class=\"lang-javascript\">option = {\n    grid: [\n        {...}, // grid 0\n        {...}  // grid 1\n    ],\n    xAxis: [\n        {gridIndex: 1, ...}, // xAxis 0 for grid 1\n        {gridIndex: 0, ...}  // xAxis 1 for grid 0\n    ],\n    yAxis: [\n        {gridIndex: 1, ...}, // yAxis 0 for grid 1\n        {gridIndex: 0, ...}  // yAxis 1 for grid 0\n    ],\n    brush: {\n        xAxisIndex: [0, 1], // brush selecting is enabled only in coordinates with xAxisIndex as `0` or `1`\n        ...\n    }\n};\n</code></pre>\n","default":null},"yAxisIndex":{"type":["Array","number","string"],"description":"<p>Assigns which of the yAxisIndex can use brush selecting.</p>\n<p><code class=\"codespan\">brush</code> can be set to be <em>global</em>, or <em>belonging to a particular coordinate</em>.</p>\n<p><strong>Global brushes</strong></p>\n<p>Selecting is enabled for everywhere in ECharts&#39;s instance in this case. This is the default situation, when brush is not set to be global.</p>\n<p><strong>Coordinate brushes</strong></p>\n<p>Selecting is enabled only in the assigned coordinates in this case. Selecting-box will be altered according to scaling and translating of coordinate (see <code class=\"codespan\">roam</code> and <code class=\"codespan\">dataZoom</code>).</p>\n<p>In practice, you may often find coordinate brush to be a more frequently made choice, particularly in <code class=\"codespan\">geo</code> charts.</p>\n<p>By assigning <a href=\"#brush.geoIndex\">brush.geoIndex</a>, or <a href=\"#brush.xAxisIndex\">brush.xAxisIndex</a>, or <a href=\"#brush.yAxisIndex\">brush.yAxisIndex</a>, brush selecting axes can be assigned, whose value can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;all&#39;</code>: for all axes;</li>\n<li><code class=\"codespan\">number</code>: like <code class=\"codespan\">0</code>, for a particular coordinate with that index;</li>\n<li><code class=\"codespan\">Array</code>: like <code class=\"codespan\">[0, 4, 2]</code>, for coordinates with those indexes;</li>\n<li><code class=\"codespan\">&#39;none&#39;</code>, or <code class=\"codespan\">null</code>, or <code class=\"codespan\">undefined</code>: for not assigning.</li>\n</ul>\n<p>Example:</p>\n<pre><code class=\"lang-javascript\">option = {\n    geo: {\n        ...\n    },\n    brush: {\n        geoIndex: &#39;all&#39;, // brush selecting is enabled only in all geo charts above\n        ...\n    }\n};\n</code></pre>\n<p>Example:</p>\n<pre><code class=\"lang-javascript\">option = {\n    grid: [\n        {...}, // grid 0\n        {...}  // grid 1\n    ],\n    xAxis: [\n        {gridIndex: 1, ...}, // xAxis 0 for grid 1\n        {gridIndex: 0, ...}  // xAxis 1 for grid 0\n    ],\n    yAxis: [\n        {gridIndex: 1, ...}, // yAxis 0 for grid 1\n        {gridIndex: 0, ...}  // yAxis 1 for grid 0\n    ],\n    brush: {\n        xAxisIndex: [0, 1], // brush selecting is enabled only in coordinates with xAxisIndex as `0` or `1`\n        ...\n    }\n};\n</code></pre>\n","default":null},"brushType":{"type":["string"],"description":"<p>Default type of brush.</p>\n<ul>\n<li><code class=\"codespan\">&#39;rect&#39;</code>: for selection-box in rectangle shape;</li>\n<li><code class=\"codespan\">&#39;polygon&#39;</code>: for selection-box in polygon shape;</li>\n<li><code class=\"codespan\">&#39;lineX&#39;</code>: for horizontal selection-box;</li>\n<li><code class=\"codespan\">&#39;lineY&#39;</code>: for vertical selection-box;</li>\n</ul>\n","default":"'rect'"},"brushMode":{"type":["string"],"description":"<p>Default brush mode, whose value can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;single&#39;</code>: for single selection;</li>\n<li><code class=\"codespan\">&#39;multiple&#39;</code>: for multiple selection.</li>\n</ul>\n","default":"'single'"},"transformable":{"type":["boolean"],"description":"<p>Determines whether a selected box can be changed in shape or translated.</p>\n","default":true},"brushStyle":{"type":["Object"],"description":"<p>Default brush style, whose value is:</p>\n<pre><code class=\"lang-javascript\">{\n    borderWidth: 1,\n    color: &#39;rgba(120,140,180,0.3)&#39;,\n    borderColor: &#39;rgba(120,140,180,0.8)&#39;\n},\n</code></pre>\n"},"throttleType":{"type":["string"],"description":"<p>By default, <code class=\"codespan\">brushSelected</code> is always triggered when selection-box is selected or moved, to tell the outside about the event.</p>\n<p>But efficiency problems may occur when events are triggered too frequently, or the animation result may be affected. So brush components provides <a href=\"#brush.throttleType\">brush.throttleType</a> and <a href=\"#brush.throttleDelay\">brush.throttleDelay</a> to solve this problem.</p>\n<p>Valid <code class=\"codespan\">throttleType</code> values can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;debounce&#39;</code>: for triggering events only when the action has been stopped (no action after some duration). Time threshold can be assigned with <a href=\"#brush.throttleDelay\">brush.throttleDelay</a>;</li>\n<li><code class=\"codespan\">&#39;fixRate&#39;</code>: for triggering event with a certain frequency. The frequency can be assigned with <a href=\"#brush.throttleDelay\">brush.throttleDelay</a>.</li>\n</ul>\n<p>In this <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-map-brush&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>, <code class=\"codespan\">debounce</code> is used to make sure the bar chart is updated only when the user has stopped action. In other cases, the animation result may not be so good.</p>\n","default":"'fixRate'"},"throttleDelay":{"type":["number"],"description":"<p><code class=\"codespan\">0</code> for disabling throttle.</p>\n<p>By default, <code class=\"codespan\">brushSelected</code> is always triggered when selection-box is selected or moved, to tell the outside about the event.</p>\n<p>But efficiency problems may occur when events are triggered too frequently, or the animation result may be affected. So brush components provides <a href=\"#brush.throttleType\">brush.throttleType</a> and <a href=\"#brush.throttleDelay\">brush.throttleDelay</a> to solve this problem.</p>\n<p>Valid <code class=\"codespan\">throttleType</code> values can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;debounce&#39;</code>: for triggering events only when the action has been stopped (no action after some duration). Time threshold can be assigned with <a href=\"#brush.throttleDelay\">brush.throttleDelay</a>;</li>\n<li><code class=\"codespan\">&#39;fixRate&#39;</code>: for triggering event with a certain frequency. The frequency can be assigned with <a href=\"#brush.throttleDelay\">brush.throttleDelay</a>.</li>\n</ul>\n<p>In this <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-map-brush&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>, <code class=\"codespan\">debounce</code> is used to make sure the bar chart is updated only when the user has stopped action. In other cases, the animation result may not be so good.</p>\n","default":0},"removeOnClick":{"type":["boolean"],"description":"<p>Defined whether <em>clearing all select-boxes on click</em> is enabled when <a href=\"#brush.brushMode\">brush.brushMode</a> is <code class=\"codespan\">&#39;single&#39;</code>.</p>\n","default":true},"inBrush":{"type":["Object"],"description":"<p>Defines visual effects of items in selection.</p>\n<p>Available visual effects include:</p>\n<ul>\n<li><code class=\"codespan\">symbol</code>: Type of symbol.</li>\n<li><code class=\"codespan\">symbolSize</code>: Symbol size.</li>\n<li><code class=\"codespan\">color</code>: Symbol color.</li>\n<li><code class=\"codespan\">colorAlpha</code>: Symbol alpha channel.</li>\n<li><code class=\"codespan\">opacity</code>: Opacity of symbol and others (like labels).</li>\n<li><code class=\"codespan\">colorLightness</code>: Lightness in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n<li><code class=\"codespan\">colorSaturation</code>: Saturation in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n<li><code class=\"codespan\">colorHue</code>: Hue in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n</ul>\n<p>In most cases, inBrush can be left unassigned, in which case default visual configuration remains.</p>\n"},"outOfBrush":{"type":["Object"],"description":"<p>Defines visual effects of items out of selection.</p>\n<p>Available visual effects include:</p>\n<ul>\n<li><code class=\"codespan\">symbol</code>: Type of symbol.</li>\n<li><code class=\"codespan\">symbolSize</code>: Symbol size.</li>\n<li><code class=\"codespan\">color</code>: Symbol color.</li>\n<li><code class=\"codespan\">colorAlpha</code>: Symbol alpha channel.</li>\n<li><code class=\"codespan\">opacity</code>: Opacity of symbol and others (like labels).</li>\n<li><code class=\"codespan\">colorLightness</code>: Lightness in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n<li><code class=\"codespan\">colorSaturation</code>: Saturation in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n<li><code class=\"codespan\">colorHue</code>: Hue in <a href=\"https://en.wikipedia.org/wiki/HSL_and_HSV\" target=\"_blank\">HSL</a>.</li>\n</ul>\n<p><strong>Note:</strong> If <code class=\"codespan\">outOfBrush</code> is not assigned, <code class=\"codespan\">color</code> will be set to be <code class=\"codespan\">&#39;#ddd&#39;</code> by default. If the color is not desired, you can use:</p>\n<pre><code class=\"lang-javascript\">brush: {\n    ...,\n    outOfBrush: {\n        colorAlpha: 0.1\n    }\n}\n</code></pre>\n"},"z":{"type":["number"],"description":"<p>z-index of brush cover box. It can be adjust when incorrect overlap occurs.</p>\n","default":10000}}},"geo":{"type":["Object"],"description":"<p>Geographic coorinate system component.</p>\n<p>Geographic coorinate system component is used to draw maps, which also supports <a href=\"#series-scatter\">scatter series</a>, and <a href=\"#series-lines\">line series</a>.</p>\n<p>From <code class=\"codespan\">3.1.10</code>, geo component also supports mouse events, whose parameters are:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;geo&#39;,\n    // geo component&#39;s index in option\n    geoIndex: number,\n    // name of clicking area, e.g., Shanghai\n    name: string,\n    // clicking region object as input, see geo.regions\n    region: Object\n}\n</code></pre>\n<p><strong>Tip:</strong>\nThe region color can also be controlled by map series. See <a href=\"#series-map.geoIndex\">series-map.geoIndex</a>.</p>\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"show":{"type":["boolean"],"description":"<p>Whether to show the geo component.</p>\n","default":true},"map":{"type":["string"],"description":"<p>Map charts.</p>\n<p>Due to the increase of fineness of map, ECharts 3 doesn&#39;t include map data by default for package size consideration. You may find map files you need on <a href=\"http://ecomfe.github.io/echarts-builder-web/map3.html\" target=\"_blank\">map download page</a> and then include and register them in ECharts.</p>\n<p>Two formats of map data are provided in ECharts, one of which can be included in <code class=\"codespan\">&lt;script&gt;</code> tag as JavaScript file, and the other of is in JSON format and should be loaded using AJAX. Map name and data will be loaded automatically once the JavaScript file is loaded, while in the JSON form, you have to assign name explicitly.</p>\n<p>Here are examples of these two types:</p>\n<p><strong> JavaScript importing example </strong></p>\n<pre><code class=\"lang-html\">&lt;script src=&quot;echarts.js&quot;&gt;&lt;/script&gt;\n&lt;script src=&quot;map/js/china.js&quot;&gt;&lt;/script&gt;\n&lt;script&gt;\nvar chart = echarts.init(document.getElmentById(&#39;main&#39;));\nchart.setOption({\n    series: [{\n        type: &#39;map&#39;,\n        map: &#39;china&#39;\n    }]\n});\n&lt;/script&gt;\n</code></pre>\n<p><strong> JSON importing example </strong></p>\n<pre><code class=\"lang-js\">$.get(&#39;map/json/china.json&#39;, function (chinaJson) {\n    echarts.registerMap(&#39;china&#39;, chinaJson);\n    var chart = echarts.init(document.getElmentById(&#39;main&#39;));\n    chart.setOption({\n        series: [{\n            type: &#39;map&#39;,\n            map: &#39;china&#39;\n        }]\n    });\n});\n</code></pre>\n<p>ECharts uses <a href=\"http://geojson.org/\" target=\"_blank\">geoJSON</a> format as map outline. Besides the methods introduced above, you can also get <a href=\"http://geojson.org/\" target=\"_blank\">geoJSON</a> data through in other methods if you like and register it in ECharts. Reference to <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=map-usa\" target=\"_blank\">USA Population Estimates</a> for more information.</p>\n","default":"''"},"roam":{"type":["boolean","string"],"description":"\n\n<p>Whether to enable mouse zooming and translating. <code class=\"codespan\">false</code> by default. If either zooming or translating is wanted, it can be set to <code class=\"codespan\">&#39;scale&#39;</code> or <code class=\"codespan\">&#39;move&#39;</code>. Otherwise, set it to be <code class=\"codespan\">true</code> to enable both.</p>\n","uiControl":{"type":"enum","options":"true,false,scale,move"},"default":false},"center":{"type":["Array"],"description":"<p>Center of current view-port, in longitude and latitude.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">center: [115.97, 29.71]\n</code></pre>\n"},"aspectScale":{"type":["number"],"description":"<p>Used to scale aspect of geo.</p>\n<p>The final aspect is calculated by: <code class=\"codespan\">geoBoundingRect.width / geoBoundingRect.height * aspectScale</code>.</p>\n","default":0.75},"boundingCoords":{"type":["Array"],"description":"<p>Two dimension array. Define coord of left-top, right-bottom in layout box.</p>\n<pre><code class=\"lang-js\">// A complete world map\nmap: &#39;world&#39;,\nleft: 0, top: 0, right: 0, bottom: 0,\nboundingCoords: [\n    // [lng, lat] of left-top corner\n    [-180, 90],\n    // [lng, lat] of right-bottom corner\n    [180, -90]\n],\n</code></pre>\n","default":null},"zoom":{"type":["number"],"description":"<p>Zoom rate of current view-port.</p>\n","default":1},"scaleLimit":{"type":["Object"],"description":"<p>Limit of scaling, with <code class=\"codespan\">min</code> and <code class=\"codespan\">max</code>. <code class=\"codespan\">1</code> by default.</p>\n","properties":{"min":{"type":["number"],"description":"<p>Minimum scaling</p>\n"},"max":{"type":["number"],"description":"<p>Maximum scaling</p>\n"}}},"nameMap":{"type":["Object"],"description":"<p>Name mapping for customized areas. For example:</p>\n<pre><code class=\"lang-js\">{\n    &#39;China&#39; : &#39;中国&#39;\n}\n</code></pre>\n"},"nameProperty":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.8.0</code></p>\n</blockquote>\n<p>customized property key for GeoJSON feature. By default, &#39;name&#39; is used as primary key to identify GeoJSON feature.\nFor example:</p>\n<pre><code class=\"lang-js\">{\n    nameProperty: &#39;NAME&#39;, // key to connect following data point to GeoJSON region {&quot;type&quot;:&quot;Feature&quot;,&quot;id&quot;:&quot;01&quot;,&quot;properties&quot;:{&quot;NAME&quot;:&quot;Alabama&quot;}, &quot;geometry&quot;: { ... }}\n    data:[\n        {name: &#39;Alabama&#39;, value: 4822023},\n        {name: &#39;Alaska&#39;, value: 731449},\n    ]\n}\n</code></pre>\n","default":"'name'"},"selectedMode":{"type":["boolean","string"],"description":"<p>Selected mode decides whether multiple selecting is supported. By default, <code class=\"codespan\">false</code> is used for disabling selection. Its value can also be <code class=\"codespan\">&#39;single&#39;</code> for selecting single area, or <code class=\"codespan\">&#39;multiple&#39;</code> for selecting multiple areas.</p>\n","default":false},"label":{"type":["Object"],"description":"<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of Map Area Border, <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"areaColor":{"type":["Color"],"description":"<p>Area filling color.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","default":"'#eee'"},"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Map area style in highlighted state.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"areaColor":{"type":["Color"],"description":"<p>The color of the map area.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","default":"'#eee'"},"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<p>Map area style in selected state.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"areaColor":{"type":["Color"],"description":"<p>The color of the map area.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","default":"'#eee'"},"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between  component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'auto'"},"top":{"type":["string","number"],"description":"<p>Distance between  component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'auto'"},"right":{"type":["string","number"],"description":"<p>Distance between  component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"bottom":{"type":["string","number"],"description":"<p>Distance between  component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"layoutCenter":{"type":["Array"],"description":"<p><code class=\"codespan\">layoutCenter</code> and <code class=\"codespan\">layoutSize</code> provides layout strategy other than <code class=\"codespan\">left/right/top/bottom/width/height</code>.</p>\n<p>When using <code class=\"codespan\">left/right/top/bottom/width/height</code>, it is hard to put the map inside a box area with a fixed width-height ratio. In this case, <code class=\"codespan\">layoutCenter</code> attribute can be used to define the center position of map, and <code class=\"codespan\">layoutSize</code> can be used to define the size of map. For example:</p>\n<pre><code class=\"lang-js\">layoutCenter: [&#39;30%&#39;, &#39;30%&#39;],\n// If width-height ratio is larger than 1, then width is set to be 100.\n// Otherwise, height is set to be 100.\n// This makes sure that it will not exceed the area of 100x100\nlayoutSize: 100\n</code></pre>\n<p>After setting these two values, <code class=\"codespan\">left/right/top/bottom/width/height</code> becomes invalid.</p>\n","default":null},"layoutSize":{"type":["number","string"],"description":"<p>Size of map, see <code class=\"codespan\">layoutCenter</code> for more information. Percentage relative to screen width, and absolute pixel values are supported.</p>\n"},"regions":{"type":["Array"],"description":"<p>Configure style for specified regions.\nFor example:</p>\n<pre><code class=\"lang-js\">regions: [{\n    name: &#39;Guangdong&#39;,\n    itemStyle: {\n        areaColor: &#39;red&#39;,\n        color: &#39;red&#39;\n    }\n}]\n</code></pre>\n<p>The region color can also be controlled by map series. See <a href=\"#series-map.geoIndex\">series-map.geoIndex</a>.</p>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Name of area in map, like <code class=\"codespan\">&#39;Guangdong&#39;</code>, or <code class=\"codespan\">&#39;Zhejiang&#39;</code>.</p>\n"},"selected":{"type":["boolean"],"description":"<p>Whether this area is selected.</p>\n","default":false},"itemStyle":{"type":["Object"],"description":"<p>Item style of this area.</p>\n","properties":{"areaColor":{"type":["Color"],"description":"<p>Area color in the map.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n"},"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"<p>Style of emphasis region.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"areaColor":{"type":["Color"],"description":"<p>The color of the map area.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n"},"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"select":{"type":["Object"],"description":"<p>Style of selected region.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"areaColor":{"type":["Color"],"description":"<p>The color of the map area.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n"},"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false}}},"parallel":{"type":["Object"],"description":"<p><strong>Introduction about Parallel coordinates</strong></p>\n<p><a href=\"https://en.wikipedia.org/wiki/Parallel_coordinates\" target=\"_blank\">Parallel Coordinates</a> is a common way of visualizing high-dimensional geometry and analyzing multivariate data.</p>\n<p>For example, <a href=\"#series-parallel.data\">series-parallel.data</a> is the following data:</p>\n<pre><code class=\"lang-javascript\">[\n    [1,  55,  9,   56,  0.46,  18,  6,  &#39;good&#39;],\n    [2,  25,  11,  21,  0.65,  34,  9,  &#39;excellent&#39;],\n    [3,  56,  7,   63,  0.3,   14,  5,  &#39;good&#39;],\n    [4,  33,  7,   29,  0.33,  16,  6,  &#39;excellent&#39;],\n    { // Data item can also be an Object, so that perticular settings of its line can be set here.\n        value: [5,  42,  24,  44,  0.76,  40,  16, &#39;excellent&#39;]\n        lineStyle: {...},\n    }\n    ...\n]\n</code></pre>\n<p>In data above, each row is a &quot;data item&quot;, and each column represents a &quot;dimension&quot;. For example, the meanings of columns above are: &quot;data&quot;, &quot;AQI&quot;, &quot;PM2.5&quot;, &quot;PM10&quot;, &quot;carbon monoxide level&quot;, &quot;nitrogen dioxide level&quot;, and &quot;sulfur dioxide level&quot;.</p>\n<p>Parallel coordinates are often used to visualize multi-dimension data shown above. Each axis represents a dimension (namely, a column), and each line represents a data item. Data can be brush-selected on axes. For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/parallel-all&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n\n<p><strong>Brief about Configuration</strong></p>\n<p>Basic configuration parallel coordinates is shown as follow:</p>\n<pre><code class=\"lang-javascript\">option = {\n    parallelAxis: [                     // Definitions of axes.\n        {dim: 0, name: schema[0].text}, // Each axis has a &#39;dim&#39; attribute, representing dimension index in data.\n        {dim: 1, name: schema[1].text},\n        {dim: 2, name: schema[2].text},\n        {dim: 3, name: schema[3].text},\n        {dim: 4, name: schema[4].text},\n        {dim: 5, name: schema[5].text},\n        {dim: 6, name: schema[6].text},\n        {dim: 7, name: schema[7].text,\n            type: &#39;category&#39;,           // Also supports category data.\n            data: [&#39;Excellent&#39;, &#39;good&#39;, &#39;light pollution&#39;, &#39;moderate pollution&#39;, &#39;heavy pollution&#39;, &#39;severe pollution&#39;]\n        }\n    ],\n    parallel: {                         // Definition of a parallel coordinate system.\n        left: &#39;5%&#39;,                     // Location of parallel coordinate system.\n        right: &#39;13%&#39;,\n        bottom: &#39;10%&#39;,\n        top: &#39;20%&#39;,\n        parallelAxisDefault: {          // A pattern for axis definition, which can avoid repeating in `parallelAxis`.\n            type: &#39;value&#39;,\n            nameLocation: &#39;end&#39;,\n            nameGap: 20\n        }\n    },\n    series: [                           // Here the three series sharing the same parallel coordinate system.\n        {\n            name: &#39;Beijing&#39;,\n            type: &#39;parallel&#39;,           // The type of this series is &#39;parallel&#39;\n            data: [\n                [1,  55,  9,   56,  0.46,  18,  6,  &#39;good&#39;],\n                [2,  25,  11,  21,  0.65,  34,  9,  &#39;excellent&#39;],\n                ...\n            ]\n        },\n        {\n            name: &#39;Shanghai&#39;,\n            type: &#39;parallel&#39;,\n            data: [\n                [3,  56,  7,   63,  0.3,   14,  5,  &#39;good&#39;],\n                [4,  33,  7,   29,  0.33,  16,  6,  &#39;excellent&#39;],\n                ...\n            ]\n        },\n        {\n            name: &#39;Guangzhou&#39;,\n            type: &#39;parallel&#39;,\n            data: [\n                [4,  33,  7,   29,  0.33,  16,  6,  &#39;excellent&#39;],\n                [5,  42,  24,  44,  0.76,  40,  16, &#39;excellent&#39;],\n                ...\n            ]\n        }\n    ]\n};\n</code></pre>\n<p>Three components are involved here: <a href=\"#parallel\">parallel</a>, <a href=\"#parallelAxis\">parallelAxis</a>, <a href=\"#series-parallel\">series-parallel</a></p>\n<ul>\n<li><p><a href=\"#parallel\">parallel</a></p>\n<p>  This component is the coordinate system. One or more series (like &quot;Beijing&quot;, &quot;Shanghai&quot;, and &quot;Guangzhou&quot; in the above example) can share one coordinate system.</p>\n<p>  Like other coordinate systems, multiple parallel coordinate systems can be created in one echarts instance.</p>\n<p>  Position setting is also carried out here.</p>\n</li>\n<li><p><a href=\"#parallelAxis\">parallelAxis</a></p>\n<p>  This is axis configuration. Multiple axes are needed in parallel coordinates.</p>\n<p>  <a href=\"#parallelAxis.parallelIndex\">parallelAxis.parallelIndex</a> is used to specify which coordinate system this axis belongs to. The first coordinate system is used by default.</p>\n</li>\n<li><p><a href=\"#series-parallel\">series-parallel</a></p>\n<p>  This is the definition of parallel series, which will be drawn on parallel coordinate system.</p>\n<p>  <a href=\"#parallelAxis.parallelIndex\">parallelAxis.parallelIndex</a> is used to specify which coordinate system this axis belongs to. The first coordinate system is used by default.</p>\n</li>\n</ul>\n<p><strong>Notes and Best Practices</strong></p>\n<p>When configuring multiple <a href=\"#parallelAxis\">parallelAxis</a>, there might be some common attributes in each axis configuration. To avoid writing them repeatly, they can be put under <a href=\"#parallel.parallelAxisDefault\">parallel.parallelAxisDefault</a>. Before initializing axis, configurations in <a href=\"#parallel.parallelAxisDefault\">parallel.parallelAxisDefault</a> will be merged into <a href=\"#parallelAxis\">parallelAxis</a> to generate the final axis configuration.</p>\n<p><strong>If data is too large and cause bad performance</strong></p>\n<p>It is suggested to set <a href=\"#series-parallel.lineStyle.width\">series-parallel.lineStyle.width</a> to be <code class=\"codespan\">0.5</code> (or less), which may improve performance significantly.</p>\n<p><strong>Display High-Dimension Data</strong></p>\n<p>When dimension number is extremely large, say, more than 50 dimensions, there will be more than 50 axes, which may hardly display in a page.</p>\n<p>In this case, you may use <a href=\"#parallel.axisExpandable\">parallel.axisExpandable</a> to improve the display. See this example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=map-parallel-prices&edit=1&reset=1\" width=\"600\" height=\"460\"></iframe>\n\n\n\n\n\n\n\n\n\n\n<p><br>\n<br></p>\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between parallel  component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":80},"top":{"type":["string","number"],"description":"<p>Distance between parallel  component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":60},"right":{"type":["string","number"],"description":"<p>Distance between parallel  component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":80},"bottom":{"type":["string","number"],"description":"<p>Distance between parallel  component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":60},"width":{"type":["string","number"],"description":"<p>Width of parallel  component. Adaptive by default.</p>\n","default":"'auto'"},"height":{"type":["string","number"],"description":"<p>Height of parallel  component. Adaptive by default.</p>\n","default":"'auto'"},"layout":{"type":["string"],"description":"\n\n<p>Layout modes, whose optional values are:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;horizontal&#39;</code>: place each axis horizontally.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;vertical&#39;</code>: place each axis vertically.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"horizontal,vertical","default":"horizontal"},"default":"'horizontal'"},"axisExpandable":{"type":["boolean"],"description":"\n\n\n\n<p>When dimension number is extremely large, say, more than 50 dimensions, there will be more than 50 axes, which may hardly display in a page.</p>\n<p>In this case, you may use <a href=\"#parallel.axisExpandable\">parallel.axisExpandable</a> to improve the display. See this example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=map-parallel-prices&edit=1&reset=1\" width=\"600\" height=\"460\"></iframe>\n\n\n\n\n\n\n<p>Whether to enable toggling axis on clicking.</p>\n","uiControl":{"type":"boolean"},"default":false},"axisExpandCenter":{"type":["number"],"description":"\n\n<p>Index of the axis which is used as the center of expanding initially. It doesn&#39;t have a default value, and needs to be assigned manually.</p>\n<p>Please refer to <a href=\"parallel.axisExpandable\" target=\"_blank\">parallel.axisExpandable</a> for more information.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":null},"axisExpandCount":{"type":["number"],"description":"\n\n<p>Defines how many axes are at expanding state initially. We&#39;d suggest you assign this value manually according to dimensions.</p>\n<p>Please refer to <a href=\"parallel.axisExpandCenter\" target=\"_blank\">parallel.axisExpandCenter</a> and <a href=\"parallel.axisExpandable\" target=\"_blank\">parallel.axisExpandable</a>.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":0},"axisExpandWidth":{"type":["number"],"description":"\n\n<p>Distance between two axes when at expanding state, in pixels.</p>\n<p>Please refer to <a href=\"parallel.axisExpandable\" target=\"_blank\">parallel.axisExpandable</a> for more information.</p>\n","uiControl":{"type":"number","min":"50","step":"1"},"default":50},"axisExpandTriggerOn":{"type":["string"],"description":"\n\n<p>Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;click&#39;</code>: Trigger expanding when mouse clicking.</li>\n<li><code class=\"codespan\">&#39;mousemove&#39;</code>: Trigger expanding when mouse hovering.</li>\n</ul>\n","uiControl":{"type":"enum","options":"click,mousemove"},"default":"'click'"},"parallelAxisDefault":{"type":["Object"],"description":"<p>When configuring multiple <a href=\"#parallelAxis\">parallelAxis</a>, there might be some common attributes in each axis configuration. To avoid writing them repeatly, they can be put under <a href=\"#parallel.parallelAxisDefault\">parallel.parallelAxisDefault</a>. Before initializing axis, configurations in <a href=\"#parallel.parallelAxisDefault\">parallel.parallelAxisDefault</a> will be merged into <a href=\"#parallelAxis\">parallelAxis</a> to generate the final axis configuration.</p>\n<p><a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/parallel-all&amp;edit=1&amp;reset=1\" target=\"_blank\">See the sample</a>.</p>\n<p><br></p>\n","properties":{"type":{"type":["string"],"description":"<p>Type of axis.</p>\n<p>Option:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;value&#39;</code>\n  Numerical axis, suitable for continuous data.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;category&#39;</code>\n  Category axis, suitable for discrete category data. Category data can be auto retrieved from <a href=\"#series.data\">series.data</a> or <a href=\"#dataset.source\">dataset.source</a>, or can be specified via <a href=\"#parallelAxis.data\">parallelAxis.data</a>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;time&#39;</code>\n  Time axis, suitable for continuous time series data. As compared to value axis, it has a better formatting for time and a different tick calculation method. For example, it decides to use month, week, day or hour for tick based on the range of span.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;log&#39;</code>\n  Log axis, suitable for log data.</p>\n</li>\n</ul>\n","default":"value"},"name":{"type":["string"],"description":"\n\n<p>Name of axis.</p>\n","uiControl":{"type":"text"}},"nameLocation":{"type":["string"],"description":"\n\n<p>Location of axis name.</p>\n<p><strong>Options: </strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> or <code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","options":"start,middle,end","default":"end"},"default":"'end'"},"nameTextStyle":{"type":["Object"],"description":"<p>Text style of axis name.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Color of axis name uses <a href=\"#parallelAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default.</p>\n","uiControl":{"type":"color"}},"fontStyle":{"type":["string"],"description":"\n\n<p>axis name font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p>axis name font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p>axis name font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p>axis name font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"nameGap":{"type":["number"],"description":"\n\n<p>Gap between axis name and axis line.</p>\n","uiControl":{"type":"number","step":"0.5","default":"15"},"default":15},"nameRotate":{"type":["number"],"description":"\n\n<p>Rotation of axis name.</p>\n","uiControl":{"type":"angle","min":"-360","max":"360","step":"1"},"default":null},"inverse":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> to invert the axis.\nThis is a new option available from Echarts 3 and newer.</p>\n","uiControl":{"type":"boolean"},"default":false},"boundaryGap":{"type":["boolean","Array"],"description":"\n\n<p>The boundary gap on both sides of a coordinate axis. The setting and behavior of category axes and non-category axes are different.</p>\n<p>The <code class=\"codespan\">boundaryGap</code> of category axis can be set to either <code class=\"codespan\">true</code> or <code class=\"codespan\">false</code>. Default value is set to be <code class=\"codespan\">true</code>, in which case <a href=\"#parallelAxis.axisTick\">axisTick</a> is served only as a separation line, and labels and data appear only in the center part of two <a href=\"#parallelAxis.axisTick\">axis ticks</a>, which is called <em>band</em>.</p>\n<p>For non-category axis, including time, numerical value, and log axes, <code class=\"codespan\">boundaryGap</code> is an array of two values, representing the spanning range between minimum and maximum value. The value can be set in numeric value or relative percentage, which becomes invalid after setting <a href=\"#parallelAxis.min\">min</a> and <a href=\"#parallelAxis.max\">max</a>.\n<strong>Example: </strong></p>\n<pre><code class=\"lang-js\">boundaryGap: [&#39;20%&#39;, &#39;20%&#39;]\n</code></pre>\n","uiControl":{"type":"boolean"}},"min":{"type":["number","string","Function"],"description":"\n\n<p>The minimun value of axis.</p>\n<p>It can be set to a special value <code class=\"codespan\">&#39;dataMin&#39;</code> so that the minimum value on this axis is set to be the minimum label.</p>\n<p>It will be automatically computed to make sure axis tick is equally distributed when not set.</p>\n<p>In category axis, it can also be set as the ordinal number. For example, if a catergory axis has <code class=\"codespan\">data: [&#39;categoryA&#39;, &#39;categoryB&#39;, &#39;categoryC&#39;]</code>, and the ordinal <code class=\"codespan\">2</code> represents <code class=\"codespan\">&#39;categoryC&#39;</code>. Moreover, it can be set as negative number, like <code class=\"codespan\">-3</code>.</p>\n<p>If <code class=\"codespan\">min</code> is specified as a function, it should return a min value, like:</p>\n<pre><code class=\"lang-js\">min: function (value) {\n    return value.min - 20;\n}\n</code></pre>\n<p><code class=\"codespan\">value</code> is an object, containing the <code class=\"codespan\">min</code> value and <code class=\"codespan\">max</code> value of the data. This function should return the min value of axis, or return <code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> to make echarts use the auto calculated min value (<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> return is only supported since <code class=\"codespan\">v4.8.0</code>).</p>\n","uiControl":{"type":"number"},"default":null},"max":{"type":["number","string","Function"],"description":"\n\n<p>The maximum value of axis.</p>\n<p>It can be set to a special value <code class=\"codespan\">&#39;dataMax&#39;</code> so that the minimum value on this axis is set to be the maximum label.</p>\n<p>It will be automatically computed to make sure axis tick is equally distributed when not set.</p>\n<p>In category axis, it can also be set as the ordinal number. For example, if a catergory axis has <code class=\"codespan\">data: [&#39;categoryA&#39;, &#39;categoryB&#39;, &#39;categoryC&#39;]</code>, and the ordinal <code class=\"codespan\">2</code> represents <code class=\"codespan\">&#39;categoryC&#39;</code>. Moreover, it can be set as negative number, like <code class=\"codespan\">-3</code>.</p>\n<p>If <code class=\"codespan\">max</code> is specified as a function, it should return a max value, like:</p>\n<pre><code class=\"lang-js\">max: function (value) {\n    return value.max - 20;\n}\n</code></pre>\n<p><code class=\"codespan\">value</code> is an object, containing the <code class=\"codespan\">min</code> value and <code class=\"codespan\">max</code> value of the data. This function should return the max value of axis, or return <code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> to make echarts use the auto calculated max value (<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> return is only supported since <code class=\"codespan\">v4.8.0</code>).</p>\n","uiControl":{"type":"number"},"default":null},"scale":{"type":["boolean"],"description":"\n\n<p>It is available only in numerical axis, i.e., <a href=\"#parallelAxis.type\">type</a>: &#39;value&#39;.</p>\n<p>It specifies whether not to contain zero position of axis compulsively. When it is set to be <code class=\"codespan\">true</code>, the axis may not contain zero position, which is useful in the scatter chart for both value axes.</p>\n<p>This configuration item is unavailable when the <a href=\"#parallelAxis.min\">min</a> and <a href=\"#parallelAxis.max\">max</a> are set.</p>\n","uiControl":{"type":"boolean"},"default":false},"splitNumber":{"type":["number"],"description":"\n\n<p>Number of segments that the axis is split into. Note that this number serves only as a recommendation, and the true segments may be adjusted based on readability.</p>\n<p>This is unavailable for category axis.</p>\n","uiControl":{"type":"number","min":"1","step":"1","default":"5"},"default":5},"minInterval":{"type":["number"],"description":"\n\n<p>Minimum gap between split lines.</p>\n<p>For example, it can be set to be <code class=\"codespan\">1</code> to make sure axis label is show as integer.</p>\n<pre><code class=\"lang-js\">{\n    minInterval: 1\n}\n</code></pre>\n<p>It is available only for axis of <a href=\"#parallelAxis.type\">type</a> &#39;value&#39; or &#39;time&#39;.</p>\n","uiControl":{"type":"number"},"default":0},"maxInterval":{"type":["number"],"description":"\n\n<p>Maximum gap between split lines.</p>\n<p>For example, in time axis (<a href=\"#parallelAxis.type\">type</a> is &#39;time&#39;), it can be set to be <code class=\"codespan\">3600 * 24 * 1000</code> to make sure that the gap between axis labels is less than or equal to one day.</p>\n<pre><code class=\"lang-js\">{\n    maxInterval: 3600 * 1000 * 24\n}\n</code></pre>\n<p>It is available only for axis of <a href=\"#parallelAxis.type\">type</a> &#39;value&#39; or &#39;time&#39;.</p>\n","uiControl":{"type":"number"}},"interval":{"type":["number"],"description":"\n\n<p>Compulsively set segmentation interval for axis.</p>\n<p>As <a href=\"#parallelAxis.splitNumber\">splitNumber</a> is a recommendation value, the calculated tick may not be the same as expected. In this case, interval should be used along with <a href=\"#parallelAxis.min\">min</a> and <a href=\"#parallelAxis.max\">max</a> to compulsively set tickings. But in most cases, we do not suggest using this, out automatic calculation is enough for most situations.</p>\n<p>This is unavailable for category axis. Timestamp should be passed for <a href=\"#parallelAxis.type\">type</a>: &#39;time&#39; axis. Logged value should be passed for <a href=\"#parallelAxis.type\">type</a>: &#39;log&#39; axis.</p>\n","uiControl":{"type":"number"}},"logBase":{"type":["number"],"description":"\n\n<p>Base of logarithm, which is valid only for numeric axes with <a href=\"#parallelAxis.type\">type</a>: &#39;log&#39;.</p>\n","uiControl":{"type":"number","default":"10"},"default":10},"silent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code>, to prevent interaction with the axis.</p>\n","default":false},"triggerEvent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code> to enable triggering events.</p>\n<p>Parameters of the event include:</p>\n<pre><code class=\"lang-js\">{\n    // Component type: xAxis, yAxis, radiusAxis, angleAxis\n    // Each of which has an attribute for index, e.g., xAxisIndex for xAxis\n    componentType: string,\n    // Value on axis before being formatted.\n    // Click on value label to trigger event.\n    value: &#39;&#39;,\n    // Name of axis.\n    // Click on laben name to trigger event.\n    name: &#39;&#39;\n}\n</code></pre>\n","default":false},"axisLine":{"type":["Object"],"description":"<p>Settings related to axis line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis line from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"symbol":{"type":["string","Array"],"description":"\n\n<p>Symbol of the two ends of the axis. It could be a string, representing the same symbol for two ends; or an array with two string elements, representing the two ends separately. It&#39;s set to be <code class=\"codespan\">&#39;none&#39;</code> by default, meaning no arrow for either end. If it is set to be <code class=\"codespan\">&#39;arrow&#39;</code>, there shall be two arrows. If there should only one arrow at the end, it should set to be <code class=\"codespan\">[&#39;none&#39;, &#39;arrow&#39;]</code>.</p>\n","uiControl":{"type":"icon","default":"none"},"default":"'none'"},"symbolSize":{"type":["Array"],"description":"\n\n<p>Size of the arrows at two ends. The first is the width perpendicular to the axis, the next is the width parallel to the axis.</p>\n","uiControl":{"type":"vector","default":"10,15"},"default":"[10, 15]"},"symbolOffset":{"type":["Array","number"],"description":"\n\n<p>Arrow offset of axis. If is array, the first number is the offset of the arrow at the beginning, and the second number is the offset of the arrow at the end. If is number, it means the arrows have the same offset.</p>\n","uiControl":{"type":"vector","default":"0,0"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>line styleLine color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#333'"},"width":{"type":["number"],"description":"\n\n<p>line style line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>line style line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisTick":{"type":["Object"],"description":"<p>Settings related to axis tick.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis tick from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"alignWithLabel":{"type":["boolean"],"description":"\n\n<p>Align axis tick with label, which is available only when <code class=\"codespan\">boundaryGap</code> is set to be <code class=\"codespan\">true</code> in category axis. See the following picture:</p>\n<p><img width=\"600\" height=\"auto\" src=\"documents/asset/img/axis-align-with-label.png\"></p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of axisTick, which is available in category axis.  is set to be the same as <a href=\"#parallelAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"inside":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> so the axis labels face the <code class=\"codespan\">inside</code> direction.</p>\n","uiControl":{"type":"boolean"},"default":false},"length":{"type":["number"],"description":"\n\n<p>The length of the axis tick.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"5"},"default":5},"lineStyle":{"type":["Object"],"description":"<p>Line style of axis ticks.</p>\n","properties":{"color":{"type":["Color"],"description":"<p>Color of axis label is set to be <a href=\"#parallelAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default.</p>\n"},"width":{"type":["number"],"description":"\n\n<p>axisTick line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>axisTick line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"minorTick":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.6.0</code></p>\n</blockquote>\n<p>Settings related minor ticks.</p>\n<p>Note: <code class=\"codespan\">minorTick</code> is not available in the <code class=\"codespan\">category</code> type axis.</p>\n<p>Examples:</p>\n<p>1) Using minor ticks in function plotting.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-function&edit=1&reset=1\" width=\"600\" height=\"350\"></iframe>\n\n\n<p>2) Using minor ticks in log axis.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-log&edit=1&reset=1\" width=\"600\" height=\"350\"></iframe>\n\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>If show minor ticks.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"splitNumber":{"type":["number"],"description":"\n\n<p>Number of interval splited by minor ticks.</p>\n","uiControl":{"type":"number","min":"1","step":"1","default":"5"},"default":5},"length":{"type":["number"],"description":"\n\n<p>Length of minor ticks lines。</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"3"},"default":3},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Style configuration of minor ticks lines <a href=\"#parallelAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a>。</p>\n","uiControl":{"type":"color"}},"width":{"type":["number"],"description":"\n\n<p>minorTick line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>minorTick line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisLabel":{"type":["Object"],"description":"<p>Settings related to axis label.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis label from appearing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis label, which is available in category axis. </p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"inside":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> so the axis labels face the <code class=\"codespan\">inside</code> direction.</p>\n","uiControl":{"type":"boolean"},"default":false},"rotate":{"type":["number"],"description":"\n\n<p>Rotation degree of axis label, which is especially useful when there is no enough space for category axis.</p>\n<p>Rotation degree is from -90 to 90.</p>\n","uiControl":{"type":"angle","min":"-90","max":"90","step":"1"},"default":0},"margin":{"type":["number"],"description":"\n\n<p>The margin between the axis label and the axis line.</p>\n","uiControl":{"type":"number","default":"8","step":"0.5"},"default":8},"formatter":{"type":["string","Function"],"description":"<p>Formatter of axis label, which supports string template and callback function.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use string template; template variable is the default label of axis {value}\nformatter: &#39;{value} kg&#39;\n// Use callback.\nformatter: function (value, index) {\n    return value + &#39;kg&#39;;\n}\n</code></pre>\n<hr>\n<p>For axes of time <a href=\"#.type\">type</a>: <code class=\"codespan\">&#39;time&#39;</code>, <code class=\"codespan\">formatter</code> supports the following forms:</p>\n<ul>\n<li><strong>String Templates</strong>: an easy and fast way to make frequently used date/time template, formed in <code class=\"codespan\">string</code></li>\n<li><strong>Callback Functions</strong>: customized formatter to make complex format, formed in <code class=\"codespan\">Function</code></li>\n<li><strong>Cascading Templates</strong>: to adopt different formatters for different time granularity, formed in <code class=\"codespan\">object</code></li>\n</ul>\n<p>Next, we are going to introduce these three forms one by one.</p>\n<p><strong> String Templates </strong></p>\n<p>Using string templates is an easy way to format date/time with frequently used formats. If it can be used to make what you want, you are advised to do so. If not, you could then consider the others. Supported formats are:</p>\n<table>\n<thead>\n<tr>\n<th>Group</th>\n<th>Template</th>\n<th>Value (EN)</th>\n<th>Value (ZH)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Year</td>\n<td>{yyyy}</td>\n<td>e.g., 2020, 2021, ...</td>\n<td>例：2020, 2021, ...</td>\n</tr>\n<tr>\n<td></td>\n<td>{yy}</td>\n<td>00-99</td>\n<td>00-99</td>\n</tr>\n<tr>\n<td>Quarter</td>\n<td>{Q}</td>\n<td>1, 2, 3, 4</td>\n<td>1, 2, 3, 4</td>\n</tr>\n<tr>\n<td>Month</td>\n<td>{MMMM}</td>\n<td>e.g., January, February, ...</td>\n<td>一月、二月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MMM}</td>\n<td>e.g., Jan, Feb, ...</td>\n<td>1月、2月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MM}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{M}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Day of Month</td>\n<td>{dd}</td>\n<td>01-31</td>\n<td>01-31</td>\n</tr>\n<tr>\n<td></td>\n<td>{d}</td>\n<td>1-31</td>\n<td>1-31</td>\n</tr>\n<tr>\n<td>Day of Week</td>\n<td>{eeee}</td>\n<td>Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday</td>\n<td>星期日、星期一、星期二、星期三、星期四、星期五、星期六</td>\n</tr>\n<tr>\n<td></td>\n<td>{ee}</td>\n<td>Sun, Mon, Tues, Wed, Thu, Fri, Sat</td>\n<td>日、一、二、三、四、五、六</td>\n</tr>\n<tr>\n<td></td>\n<td>{e}</td>\n<td>1-54</td>\n<td>1-54</td>\n</tr>\n<tr>\n<td>Hour</td>\n<td>{HH}</td>\n<td>00-23</td>\n<td>00-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{H}</td>\n<td>0-23</td>\n<td>0-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{hh}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{h}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Minute</td>\n<td>{mm}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{m}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Second</td>\n<td>{ss}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{s}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Millisecond</td>\n<td>{SSS}</td>\n<td>000-999</td>\n<td>000-999</td>\n</tr>\n<tr>\n<td></td>\n<td>{S}</td>\n<td>0-999</td>\n<td>0-999</td>\n</tr>\n</tbody>\n</table>\n<blockquote>\n<p>Templates of other languages can be found in <a href=\"https://github.com/apache/echarts/tree/master/src/i18n\" target=\"_blank\">the language package</a>. Please refer to <a href=\"api.html#echarts.registerLocale\" target=\"_blank\">echarts.registerLocale</a> to register a language.</p>\n</blockquote>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: &#39;{yyyy}-{MM}-{dd}&#39; // gets labels like &#39;2020-12-02&#39;\nformatter: &#39;Day {d}&#39; // gets labels like &#39;Day 2&#39;\n</code></pre>\n<p><strong> Callback Functions </strong></p>\n<p>Callback functions can be used to get different formats for different axis tick values. Sometimes, if you have complex date/time formatting requirement, third-party libraries like <a href=\"https://momentjs.com/\" target=\"_blank\">Moment.js</a> or <a href=\"https://date-fns.org/\" target=\"_blank\">date-fns</a> can be used to return formatted labels.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use callback function; function parameters are axis index\nformatter: function (value, index) {\n    // Formatted to be month/day; display year only in the first label\n    var date = new Date(value);\n    var texts = [(date.getMonth() + 1), date.getDate()];\n    if (idx === 0) {\n        texts.unshift(date.getYear());\n    }\n    return texts.join(&#39;/&#39;);\n}\n</code></pre>\n<p><strong> Cascading Templates </strong></p>\n<p>Sometimes, we wish to use different formats for different time granularity. For example, in a quarter-year chart, we may wish to see the month name with the first date of the month, while see the date name with others. This can be made with:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: {\n    month: &#39;{MMMM}&#39;, // Jan, Feb, ...\n    day: &#39;{d}&#39; // 1, 2, ...\n}\n</code></pre>\n<p>Supported levels and their default formatters are:</p>\n<pre><code class=\"lang-js\">{\n    year: &#39;{yyyy}&#39;,\n    month: &#39;{MMM}&#39;,\n    day: &#39;{d}&#39;,\n    hour: &#39;{HH}:{mm}&#39;,\n    minute: &#39;{HH}:{mm}&#39;,\n    second: &#39;{HH}:{mm}:{ss}&#39;,\n    millisecond: &#39;{hh}:{mm}:{ss} {SSS}&#39;,\n    none: &#39;{yyyy}-{MM}-{dd} {hh}:{mm}:{ss} {SSS}&#39;\n}\n</code></pre>\n<p>Let&#39;s take <code class=\"codespan\">day</code> for example. When a tick value is <code class=\"codespan\">0</code> for its hour, minute, second, and millisecond, <code class=\"codespan\">day</code> level will be used to make formatter. <code class=\"codespan\">none</code> is used when no other level fulfills, which is for tick values with millisecond values other than <code class=\"codespan\">0</code>.</p>\n<p><strong> Rich Text </strong></p>\n<p>The above three forms all support rich text, so it can be used to make some complex effects.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: {\n            // Display year and month information on the first data of a year\n            year: &#39;{yearStyle|{yyyy}}\\n{monthStyle|{MMM}}&#39;,\n            month: &#39;{monthStyle|{MMM}}&#39;\n        },\n        rich: {\n            yearStyle: {\n                // Make yearly text more standing out\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            monthStyle: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n<p>The above example can also be made with a callback function:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: function (value) {\n            const date = new Date(value);\n            const yearStart = new Date(value);\n            yearStart.setMonth(0);\n            yearStart.setDate(1);\n            yearStart.setHours(0);\n            yearStart.setMinutes(0);\n            yearStart.setSeconds(0);\n            yearStart.setMilliseconds(0);\n            // Whether a tick value is the start of a year\n            if (date.getTime() === yearStart.getTime()) {\n                return &#39;{year|&#39; + date.getFullYear() + &#39;}\\n&#39;\n                    + &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;;\n            }\n            else {\n                return &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;\n            }\n        },\n        rich: {\n            year: {\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            month: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n","default":null},"showMinLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the min tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the min tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"showMaxLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the max tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the max tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"color":{"type":["Color","Function"],"description":"\n\n<p>Color of axis label is set to be <a href=\"#parallelAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default. Callback function is supported, in the following format:</p>\n<pre><code class=\"lang-js\">(val: string) =&gt; Color\n</code></pre>\n<p>Parameter is the text of label, and return value is the color. See the following example:</p>\n<pre><code class=\"lang-js\">textStyle: {\n    color: function (value, index) {\n        return value &gt;= 0 ? &#39;green&#39; : &#39;red&#39;;\n    }\n}\n</code></pre>\n","uiControl":{"type":"color"}},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"data":{"type":["Array"],"description":"<p>Category data, available in <a href=\"#parallelAxis.type\">type</a>: &#39;category&#39; axis.</p>\n<p>If <a href=\"#parallelAxis.type\">type</a> is not specified, but <code class=\"codespan\">axis.data</code> is specified, the <a href=\"#parallelAxis.type\">type</a> is auto set as <code class=\"codespan\">&#39;category&#39;</code>.</p>\n<p>If <a href=\"#parallelAxis.type\">type</a> is specified as <code class=\"codespan\">&#39;category&#39;</code>, but <code class=\"codespan\">axis.data</code> is not specified, <code class=\"codespan\">axis.data</code> will be auto collected from <a href=\"#series.data\">series.data</a>. It brings convenience, but we should notice that <code class=\"codespan\">axis.data</code> provides then value range of the <code class=\"codespan\">&#39;category&#39;</code> axis. If  it is auto collected from <a href=\"#series.data\">series.data</a>, Only the values appearing in <a href=\"#series.data\">series.data</a> can be collected. For example, if <a href=\"#series.data\">series.data</a> is empty, nothing will be collected.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Name list of all categories\ndata: [&#39;Monday&#39;, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;, &#39;Friday&#39;, &#39;Saturday&#39;, &#39;Sunday&#39;]\n// Each item could also be a specific configuration item.\n// In this case, `value` is used as the category name.\ndata: [{\n    value: &#39;Monday&#39;,\n    // Highlight Monday\n    textStyle: {\n        fontSize: 20,\n        color: &#39;red&#39;\n    }\n}, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;, &#39;Friday&#39;, &#39;Saturday&#39;, &#39;Sunday&#39;]\n</code></pre>\n","items":{"type":"Object","properties":{"value":{"type":["string"],"description":"<p>Name of a category.</p>\n"},"textStyle":{"type":["Object"],"description":"<p>Text style of the category.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}}},"parallelAxis":{"type":["Object"],"description":"<p>This component is the coordinate axis for parallel coordinate.</p>\n<p><strong>Introduction about Parallel coordinates</strong></p>\n<p><a href=\"https://en.wikipedia.org/wiki/Parallel_coordinates\" target=\"_blank\">Parallel Coordinates</a> is a common way of visualizing high-dimensional geometry and analyzing multivariate data.</p>\n<p>For example, <a href=\"#series-parallel.data\">series-parallel.data</a> is the following data:</p>\n<pre><code class=\"lang-javascript\">[\n    [1,  55,  9,   56,  0.46,  18,  6,  &#39;good&#39;],\n    [2,  25,  11,  21,  0.65,  34,  9,  &#39;excellent&#39;],\n    [3,  56,  7,   63,  0.3,   14,  5,  &#39;good&#39;],\n    [4,  33,  7,   29,  0.33,  16,  6,  &#39;excellent&#39;],\n    { // Data item can also be an Object, so that perticular settings of its line can be set here.\n        value: [5,  42,  24,  44,  0.76,  40,  16, &#39;excellent&#39;]\n        lineStyle: {...},\n    }\n    ...\n]\n</code></pre>\n<p>In data above, each row is a &quot;data item&quot;, and each column represents a &quot;dimension&quot;. For example, the meanings of columns above are: &quot;data&quot;, &quot;AQI&quot;, &quot;PM2.5&quot;, &quot;PM10&quot;, &quot;carbon monoxide level&quot;, &quot;nitrogen dioxide level&quot;, and &quot;sulfur dioxide level&quot;.</p>\n<p>Parallel coordinates are often used to visualize multi-dimension data shown above. Each axis represents a dimension (namely, a column), and each line represents a data item. Data can be brush-selected on axes. For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/parallel-all&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n\n<p><strong>Brief about Configuration</strong></p>\n<p>Basic configuration parallel coordinates is shown as follow:</p>\n<pre><code class=\"lang-javascript\">option = {\n    parallelAxis: [                     // Definitions of axes.\n        {dim: 0, name: schema[0].text}, // Each axis has a &#39;dim&#39; attribute, representing dimension index in data.\n        {dim: 1, name: schema[1].text},\n        {dim: 2, name: schema[2].text},\n        {dim: 3, name: schema[3].text},\n        {dim: 4, name: schema[4].text},\n        {dim: 5, name: schema[5].text},\n        {dim: 6, name: schema[6].text},\n        {dim: 7, name: schema[7].text,\n            type: &#39;category&#39;,           // Also supports category data.\n            data: [&#39;Excellent&#39;, &#39;good&#39;, &#39;light pollution&#39;, &#39;moderate pollution&#39;, &#39;heavy pollution&#39;, &#39;severe pollution&#39;]\n        }\n    ],\n    parallel: {                         // Definition of a parallel coordinate system.\n        left: &#39;5%&#39;,                     // Location of parallel coordinate system.\n        right: &#39;13%&#39;,\n        bottom: &#39;10%&#39;,\n        top: &#39;20%&#39;,\n        parallelAxisDefault: {          // A pattern for axis definition, which can avoid repeating in `parallelAxis`.\n            type: &#39;value&#39;,\n            nameLocation: &#39;end&#39;,\n            nameGap: 20\n        }\n    },\n    series: [                           // Here the three series sharing the same parallel coordinate system.\n        {\n            name: &#39;Beijing&#39;,\n            type: &#39;parallel&#39;,           // The type of this series is &#39;parallel&#39;\n            data: [\n                [1,  55,  9,   56,  0.46,  18,  6,  &#39;good&#39;],\n                [2,  25,  11,  21,  0.65,  34,  9,  &#39;excellent&#39;],\n                ...\n            ]\n        },\n        {\n            name: &#39;Shanghai&#39;,\n            type: &#39;parallel&#39;,\n            data: [\n                [3,  56,  7,   63,  0.3,   14,  5,  &#39;good&#39;],\n                [4,  33,  7,   29,  0.33,  16,  6,  &#39;excellent&#39;],\n                ...\n            ]\n        },\n        {\n            name: &#39;Guangzhou&#39;,\n            type: &#39;parallel&#39;,\n            data: [\n                [4,  33,  7,   29,  0.33,  16,  6,  &#39;excellent&#39;],\n                [5,  42,  24,  44,  0.76,  40,  16, &#39;excellent&#39;],\n                ...\n            ]\n        }\n    ]\n};\n</code></pre>\n<p>Three components are involved here: <a href=\"#parallel\">parallel</a>, <a href=\"#parallelAxis\">parallelAxis</a>, <a href=\"#series-parallel\">series-parallel</a></p>\n<ul>\n<li><p><a href=\"#parallel\">parallel</a></p>\n<p>  This component is the coordinate system. One or more series (like &quot;Beijing&quot;, &quot;Shanghai&quot;, and &quot;Guangzhou&quot; in the above example) can share one coordinate system.</p>\n<p>  Like other coordinate systems, multiple parallel coordinate systems can be created in one echarts instance.</p>\n<p>  Position setting is also carried out here.</p>\n</li>\n<li><p><a href=\"#parallelAxis\">parallelAxis</a></p>\n<p>  This is axis configuration. Multiple axes are needed in parallel coordinates.</p>\n<p>  <a href=\"#parallelAxis.parallelIndex\">parallelAxis.parallelIndex</a> is used to specify which coordinate system this axis belongs to. The first coordinate system is used by default.</p>\n</li>\n<li><p><a href=\"#series-parallel\">series-parallel</a></p>\n<p>  This is the definition of parallel series, which will be drawn on parallel coordinate system.</p>\n<p>  <a href=\"#parallelAxis.parallelIndex\">parallelAxis.parallelIndex</a> is used to specify which coordinate system this axis belongs to. The first coordinate system is used by default.</p>\n</li>\n</ul>\n<p><strong>Notes and Best Practices</strong></p>\n<p>When configuring multiple <a href=\"#parallelAxis\">parallelAxis</a>, there might be some common attributes in each axis configuration. To avoid writing them repeatly, they can be put under <a href=\"#parallel.parallelAxisDefault\">parallel.parallelAxisDefault</a>. Before initializing axis, configurations in <a href=\"#parallel.parallelAxisDefault\">parallel.parallelAxisDefault</a> will be merged into <a href=\"#parallelAxis\">parallelAxis</a> to generate the final axis configuration.</p>\n<p><strong>If data is too large and cause bad performance</strong></p>\n<p>It is suggested to set <a href=\"#series-parallel.lineStyle.width\">series-parallel.lineStyle.width</a> to be <code class=\"codespan\">0.5</code> (or less), which may improve performance significantly.</p>\n<p><strong>Display High-Dimension Data</strong></p>\n<p>When dimension number is extremely large, say, more than 50 dimensions, there will be more than 50 axes, which may hardly display in a page.</p>\n<p>In this case, you may use <a href=\"#parallel.axisExpandable\">parallel.axisExpandable</a> to improve the display. See this example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=map-parallel-prices&edit=1&reset=1\" width=\"600\" height=\"460\"></iframe>\n\n\n\n\n\n\n\n\n\n\n<p><br>\n<br></p>\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"dim":{"type":["number"],"description":"<p>Dimension index of coordinate axis.</p>\n<p>For example, <a href=\"#series-parallel.data\">series-parallel.data</a> is the following data:</p>\n<pre><code class=\"lang-javascript\">[\n    [1,  55,  9,   56,  0.46,  18,  6,  &#39;good&#39;],\n    [2,  25,  11,  21,  0.65,  34,  9,  &#39;excellent&#39;],\n    [3,  56,  7,   63,  0.3,   14,  5,  &#39;good&#39;],\n    [4,  33,  7,   29,  0.33,  16,  6,  &#39;excellent&#39;],\n    { // Data item can also be an Object, so that perticular settings of its line can be set here.\n        value: [5,  42,  24,  44,  0.76,  40,  16, &#39;excellent&#39;]\n        lineStyle: {...},\n    }\n    ...\n]\n</code></pre>\n<p>In data above, each row is a &quot;data item&quot;, and each column represents a &quot;dimension&quot;. For example, the meanings of columns above are: &quot;data&quot;, &quot;AQI&quot;, &quot;PM2.5&quot;, &quot;PM10&quot;, &quot;carbon monoxide level&quot;, &quot;nitrogen dioxide level&quot;, and &quot;sulfur dioxide level&quot;.</p>\n<p><code class=\"codespan\">dim</code> defines which dimension (which <em>row</em>) of data would map to this axis.</p>\n<p>Started from <code class=\"codespan\">0</code>. For example, if the <code class=\"codespan\">dim</code> of coordinate axis is <code class=\"codespan\">1</code>, it indicates that the second row of data would map to this axis.</p>\n"},"parallelIndex":{"type":["number"],"description":"<p>It is used to define which <em>coordinate</em> the <em>axis</em> should map to.</p>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">myChart.setOption({\n    parallel: [\n        {...},                      // the first parallel coordinate\n        {...}                       // the second parallel coordinate\n    ],\n    parallelAxis: [\n        {parallelIndex: 1, ...},    // the first coordinate axis, mapping to the second parallel coordinate\n        {parallelIndex: 0, ...},    //  the second coordinate axis, mapping to the first parallel coordinate\n        {parallelIndex: 1, ...},    //  the third coordinate axis, mapping to the second parallel coordinate\n        {parallelIndex: 0, ...}     //  the fourth coordinate axis, mapping to the first parallel coordinate\n    ],\n    ...\n});\n</code></pre>\n<p>If there is only one parallel coordinate, you don&#39;t have to configure it, whose default value is <code class=\"codespan\">0</code>.</p>\n","default":0},"realtime":{"type":["boolean"],"description":"\n\n<p>Whether to refresh view when brush-selecting axis. If is set to be <code class=\"codespan\">false</code>, view is updated after brush-selecting action ends.</p>\n<p>When data amount is large, it is suggested to set to be <code class=\"codespan\">false</code> to avoid efficiency problems.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"areaSelectStyle":{"type":["Object"],"description":"<p>Area selecting is available on axes. Here is some configurations.</p>\n<p><br></p>\n","properties":{"width":{"type":["number"],"description":"\n\n<p>Width of selecting box.</p>\n","uiControl":{"type":"number","min":"0","default":"20","step":"1"},"default":20},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the select box.</p>\n","uiControl":{"type":"number","min":"0","default":"1","step":"0.5"},"default":1},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the select box.</p>\n","uiControl":{"type":"color","default":"rgba(160,197,232)"},"default":"'rgba(160,197,232)'"},"color":{"type":["Color"],"description":"\n\n<p>Border fill color of the select box.</p>\n","uiControl":{"type":"color","default":"rgba(160,197,232)"},"default":"'rgba(160,197,232)'"},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the select box.</p>\n","uiControl":{"type":"number","min":"0","max":"1","default":"0.3"},"default":0.3}}},"type":{"type":["string"],"description":"<p>Type of axis.</p>\n<p>Option:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;value&#39;</code>\n  Numerical axis, suitable for continuous data.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;category&#39;</code>\n  Category axis, suitable for discrete category data. Category data can be auto retrieved from <a href=\"#series.data\">series.data</a> or <a href=\"#dataset.source\">dataset.source</a>, or can be specified via <a href=\"#parallelAxis.data\">parallelAxis.data</a>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;time&#39;</code>\n  Time axis, suitable for continuous time series data. As compared to value axis, it has a better formatting for time and a different tick calculation method. For example, it decides to use month, week, day or hour for tick based on the range of span.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;log&#39;</code>\n  Log axis, suitable for log data.</p>\n</li>\n</ul>\n","default":"value"},"name":{"type":["string"],"description":"\n\n<p>Name of axis.</p>\n","uiControl":{"type":"text"}},"nameLocation":{"type":["string"],"description":"\n\n<p>Location of axis name.</p>\n<p><strong>Options: </strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> or <code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","options":"start,middle,end","default":"end"},"default":"'end'"},"nameTextStyle":{"type":["Object"],"description":"<p>Text style of axis name.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Color of axis name uses <a href=\"#parallelAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default.</p>\n","uiControl":{"type":"color"}},"fontStyle":{"type":["string"],"description":"\n\n<p>axis name font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p>axis name font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p>axis name font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p>axis name font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"nameGap":{"type":["number"],"description":"\n\n<p>Gap between axis name and axis line.</p>\n","uiControl":{"type":"number","step":"0.5","default":"15"},"default":15},"nameRotate":{"type":["number"],"description":"\n\n<p>Rotation of axis name.</p>\n","uiControl":{"type":"angle","min":"-360","max":"360","step":"1"},"default":null},"inverse":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> to invert the axis.\nThis is a new option available from Echarts 3 and newer.</p>\n","uiControl":{"type":"boolean"},"default":false},"boundaryGap":{"type":["boolean","Array"],"description":"\n\n<p>The boundary gap on both sides of a coordinate axis. The setting and behavior of category axes and non-category axes are different.</p>\n<p>The <code class=\"codespan\">boundaryGap</code> of category axis can be set to either <code class=\"codespan\">true</code> or <code class=\"codespan\">false</code>. Default value is set to be <code class=\"codespan\">true</code>, in which case <a href=\"#parallelAxis.axisTick\">axisTick</a> is served only as a separation line, and labels and data appear only in the center part of two <a href=\"#parallelAxis.axisTick\">axis ticks</a>, which is called <em>band</em>.</p>\n<p>For non-category axis, including time, numerical value, and log axes, <code class=\"codespan\">boundaryGap</code> is an array of two values, representing the spanning range between minimum and maximum value. The value can be set in numeric value or relative percentage, which becomes invalid after setting <a href=\"#parallelAxis.min\">min</a> and <a href=\"#parallelAxis.max\">max</a>.\n<strong>Example: </strong></p>\n<pre><code class=\"lang-js\">boundaryGap: [&#39;20%&#39;, &#39;20%&#39;]\n</code></pre>\n","uiControl":{"type":"boolean"}},"min":{"type":["number","string","Function"],"description":"\n\n<p>The minimun value of axis.</p>\n<p>It can be set to a special value <code class=\"codespan\">&#39;dataMin&#39;</code> so that the minimum value on this axis is set to be the minimum label.</p>\n<p>It will be automatically computed to make sure axis tick is equally distributed when not set.</p>\n<p>In category axis, it can also be set as the ordinal number. For example, if a catergory axis has <code class=\"codespan\">data: [&#39;categoryA&#39;, &#39;categoryB&#39;, &#39;categoryC&#39;]</code>, and the ordinal <code class=\"codespan\">2</code> represents <code class=\"codespan\">&#39;categoryC&#39;</code>. Moreover, it can be set as negative number, like <code class=\"codespan\">-3</code>.</p>\n<p>If <code class=\"codespan\">min</code> is specified as a function, it should return a min value, like:</p>\n<pre><code class=\"lang-js\">min: function (value) {\n    return value.min - 20;\n}\n</code></pre>\n<p><code class=\"codespan\">value</code> is an object, containing the <code class=\"codespan\">min</code> value and <code class=\"codespan\">max</code> value of the data. This function should return the min value of axis, or return <code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> to make echarts use the auto calculated min value (<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> return is only supported since <code class=\"codespan\">v4.8.0</code>).</p>\n","uiControl":{"type":"number"},"default":null},"max":{"type":["number","string","Function"],"description":"\n\n<p>The maximum value of axis.</p>\n<p>It can be set to a special value <code class=\"codespan\">&#39;dataMax&#39;</code> so that the minimum value on this axis is set to be the maximum label.</p>\n<p>It will be automatically computed to make sure axis tick is equally distributed when not set.</p>\n<p>In category axis, it can also be set as the ordinal number. For example, if a catergory axis has <code class=\"codespan\">data: [&#39;categoryA&#39;, &#39;categoryB&#39;, &#39;categoryC&#39;]</code>, and the ordinal <code class=\"codespan\">2</code> represents <code class=\"codespan\">&#39;categoryC&#39;</code>. Moreover, it can be set as negative number, like <code class=\"codespan\">-3</code>.</p>\n<p>If <code class=\"codespan\">max</code> is specified as a function, it should return a max value, like:</p>\n<pre><code class=\"lang-js\">max: function (value) {\n    return value.max - 20;\n}\n</code></pre>\n<p><code class=\"codespan\">value</code> is an object, containing the <code class=\"codespan\">min</code> value and <code class=\"codespan\">max</code> value of the data. This function should return the max value of axis, or return <code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> to make echarts use the auto calculated max value (<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> return is only supported since <code class=\"codespan\">v4.8.0</code>).</p>\n","uiControl":{"type":"number"},"default":null},"scale":{"type":["boolean"],"description":"\n\n<p>It is available only in numerical axis, i.e., <a href=\"#parallelAxis.type\">type</a>: &#39;value&#39;.</p>\n<p>It specifies whether not to contain zero position of axis compulsively. When it is set to be <code class=\"codespan\">true</code>, the axis may not contain zero position, which is useful in the scatter chart for both value axes.</p>\n<p>This configuration item is unavailable when the <a href=\"#parallelAxis.min\">min</a> and <a href=\"#parallelAxis.max\">max</a> are set.</p>\n","uiControl":{"type":"boolean"},"default":false},"splitNumber":{"type":["number"],"description":"\n\n<p>Number of segments that the axis is split into. Note that this number serves only as a recommendation, and the true segments may be adjusted based on readability.</p>\n<p>This is unavailable for category axis.</p>\n","uiControl":{"type":"number","min":"1","step":"1","default":"5"},"default":5},"minInterval":{"type":["number"],"description":"\n\n<p>Minimum gap between split lines.</p>\n<p>For example, it can be set to be <code class=\"codespan\">1</code> to make sure axis label is show as integer.</p>\n<pre><code class=\"lang-js\">{\n    minInterval: 1\n}\n</code></pre>\n<p>It is available only for axis of <a href=\"#parallelAxis.type\">type</a> &#39;value&#39; or &#39;time&#39;.</p>\n","uiControl":{"type":"number"},"default":0},"maxInterval":{"type":["number"],"description":"\n\n<p>Maximum gap between split lines.</p>\n<p>For example, in time axis (<a href=\"#parallelAxis.type\">type</a> is &#39;time&#39;), it can be set to be <code class=\"codespan\">3600 * 24 * 1000</code> to make sure that the gap between axis labels is less than or equal to one day.</p>\n<pre><code class=\"lang-js\">{\n    maxInterval: 3600 * 1000 * 24\n}\n</code></pre>\n<p>It is available only for axis of <a href=\"#parallelAxis.type\">type</a> &#39;value&#39; or &#39;time&#39;.</p>\n","uiControl":{"type":"number"}},"interval":{"type":["number"],"description":"\n\n<p>Compulsively set segmentation interval for axis.</p>\n<p>As <a href=\"#parallelAxis.splitNumber\">splitNumber</a> is a recommendation value, the calculated tick may not be the same as expected. In this case, interval should be used along with <a href=\"#parallelAxis.min\">min</a> and <a href=\"#parallelAxis.max\">max</a> to compulsively set tickings. But in most cases, we do not suggest using this, out automatic calculation is enough for most situations.</p>\n<p>This is unavailable for category axis. Timestamp should be passed for <a href=\"#parallelAxis.type\">type</a>: &#39;time&#39; axis. Logged value should be passed for <a href=\"#parallelAxis.type\">type</a>: &#39;log&#39; axis.</p>\n","uiControl":{"type":"number"}},"logBase":{"type":["number"],"description":"\n\n<p>Base of logarithm, which is valid only for numeric axes with <a href=\"#parallelAxis.type\">type</a>: &#39;log&#39;.</p>\n","uiControl":{"type":"number","default":"10"},"default":10},"silent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code>, to prevent interaction with the axis.</p>\n","default":false},"triggerEvent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code> to enable triggering events.</p>\n<p>Parameters of the event include:</p>\n<pre><code class=\"lang-js\">{\n    // Component type: xAxis, yAxis, radiusAxis, angleAxis\n    // Each of which has an attribute for index, e.g., xAxisIndex for xAxis\n    componentType: string,\n    // Value on axis before being formatted.\n    // Click on value label to trigger event.\n    value: &#39;&#39;,\n    // Name of axis.\n    // Click on laben name to trigger event.\n    name: &#39;&#39;\n}\n</code></pre>\n","default":false},"axisLine":{"type":["Object"],"description":"<p>Settings related to axis line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis line from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"symbol":{"type":["string","Array"],"description":"\n\n<p>Symbol of the two ends of the axis. It could be a string, representing the same symbol for two ends; or an array with two string elements, representing the two ends separately. It&#39;s set to be <code class=\"codespan\">&#39;none&#39;</code> by default, meaning no arrow for either end. If it is set to be <code class=\"codespan\">&#39;arrow&#39;</code>, there shall be two arrows. If there should only one arrow at the end, it should set to be <code class=\"codespan\">[&#39;none&#39;, &#39;arrow&#39;]</code>.</p>\n","uiControl":{"type":"icon","default":"none"},"default":"'none'"},"symbolSize":{"type":["Array"],"description":"\n\n<p>Size of the arrows at two ends. The first is the width perpendicular to the axis, the next is the width parallel to the axis.</p>\n","uiControl":{"type":"vector","default":"10,15"},"default":"[10, 15]"},"symbolOffset":{"type":["Array","number"],"description":"\n\n<p>Arrow offset of axis. If is array, the first number is the offset of the arrow at the beginning, and the second number is the offset of the arrow at the end. If is number, it means the arrows have the same offset.</p>\n","uiControl":{"type":"vector","default":"0,0"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>line styleLine color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#333'"},"width":{"type":["number"],"description":"\n\n<p>line style line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>line style line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisTick":{"type":["Object"],"description":"<p>Settings related to axis tick.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis tick from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"alignWithLabel":{"type":["boolean"],"description":"\n\n<p>Align axis tick with label, which is available only when <code class=\"codespan\">boundaryGap</code> is set to be <code class=\"codespan\">true</code> in category axis. See the following picture:</p>\n<p><img width=\"600\" height=\"auto\" src=\"documents/asset/img/axis-align-with-label.png\"></p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of axisTick, which is available in category axis.  is set to be the same as <a href=\"#parallelAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"inside":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> so the axis labels face the <code class=\"codespan\">inside</code> direction.</p>\n","uiControl":{"type":"boolean"},"default":false},"length":{"type":["number"],"description":"\n\n<p>The length of the axis tick.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"5"},"default":5},"lineStyle":{"type":["Object"],"description":"<p>Line style of axis ticks.</p>\n","properties":{"color":{"type":["Color"],"description":"<p>Color of axis label is set to be <a href=\"#parallelAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default.</p>\n"},"width":{"type":["number"],"description":"\n\n<p>axisTick line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>axisTick line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"minorTick":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.6.0</code></p>\n</blockquote>\n<p>Settings related minor ticks.</p>\n<p>Note: <code class=\"codespan\">minorTick</code> is not available in the <code class=\"codespan\">category</code> type axis.</p>\n<p>Examples:</p>\n<p>1) Using minor ticks in function plotting.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-function&edit=1&reset=1\" width=\"600\" height=\"350\"></iframe>\n\n\n<p>2) Using minor ticks in log axis.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-log&edit=1&reset=1\" width=\"600\" height=\"350\"></iframe>\n\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>If show minor ticks.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"splitNumber":{"type":["number"],"description":"\n\n<p>Number of interval splited by minor ticks.</p>\n","uiControl":{"type":"number","min":"1","step":"1","default":"5"},"default":5},"length":{"type":["number"],"description":"\n\n<p>Length of minor ticks lines。</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"3"},"default":3},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Style configuration of minor ticks lines <a href=\"#parallelAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a>。</p>\n","uiControl":{"type":"color"}},"width":{"type":["number"],"description":"\n\n<p>minorTick line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>minorTick line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisLabel":{"type":["Object"],"description":"<p>Settings related to axis label.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis label from appearing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis label, which is available in category axis. </p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"inside":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> so the axis labels face the <code class=\"codespan\">inside</code> direction.</p>\n","uiControl":{"type":"boolean"},"default":false},"rotate":{"type":["number"],"description":"\n\n<p>Rotation degree of axis label, which is especially useful when there is no enough space for category axis.</p>\n<p>Rotation degree is from -90 to 90.</p>\n","uiControl":{"type":"angle","min":"-90","max":"90","step":"1"},"default":0},"margin":{"type":["number"],"description":"\n\n<p>The margin between the axis label and the axis line.</p>\n","uiControl":{"type":"number","default":"8","step":"0.5"},"default":8},"formatter":{"type":["string","Function"],"description":"<p>Formatter of axis label, which supports string template and callback function.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use string template; template variable is the default label of axis {value}\nformatter: &#39;{value} kg&#39;\n// Use callback.\nformatter: function (value, index) {\n    return value + &#39;kg&#39;;\n}\n</code></pre>\n<hr>\n<p>For axes of time <a href=\"#.type\">type</a>: <code class=\"codespan\">&#39;time&#39;</code>, <code class=\"codespan\">formatter</code> supports the following forms:</p>\n<ul>\n<li><strong>String Templates</strong>: an easy and fast way to make frequently used date/time template, formed in <code class=\"codespan\">string</code></li>\n<li><strong>Callback Functions</strong>: customized formatter to make complex format, formed in <code class=\"codespan\">Function</code></li>\n<li><strong>Cascading Templates</strong>: to adopt different formatters for different time granularity, formed in <code class=\"codespan\">object</code></li>\n</ul>\n<p>Next, we are going to introduce these three forms one by one.</p>\n<p><strong> String Templates </strong></p>\n<p>Using string templates is an easy way to format date/time with frequently used formats. If it can be used to make what you want, you are advised to do so. If not, you could then consider the others. Supported formats are:</p>\n<table>\n<thead>\n<tr>\n<th>Group</th>\n<th>Template</th>\n<th>Value (EN)</th>\n<th>Value (ZH)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Year</td>\n<td>{yyyy}</td>\n<td>e.g., 2020, 2021, ...</td>\n<td>例：2020, 2021, ...</td>\n</tr>\n<tr>\n<td></td>\n<td>{yy}</td>\n<td>00-99</td>\n<td>00-99</td>\n</tr>\n<tr>\n<td>Quarter</td>\n<td>{Q}</td>\n<td>1, 2, 3, 4</td>\n<td>1, 2, 3, 4</td>\n</tr>\n<tr>\n<td>Month</td>\n<td>{MMMM}</td>\n<td>e.g., January, February, ...</td>\n<td>一月、二月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MMM}</td>\n<td>e.g., Jan, Feb, ...</td>\n<td>1月、2月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MM}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{M}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Day of Month</td>\n<td>{dd}</td>\n<td>01-31</td>\n<td>01-31</td>\n</tr>\n<tr>\n<td></td>\n<td>{d}</td>\n<td>1-31</td>\n<td>1-31</td>\n</tr>\n<tr>\n<td>Day of Week</td>\n<td>{eeee}</td>\n<td>Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday</td>\n<td>星期日、星期一、星期二、星期三、星期四、星期五、星期六</td>\n</tr>\n<tr>\n<td></td>\n<td>{ee}</td>\n<td>Sun, Mon, Tues, Wed, Thu, Fri, Sat</td>\n<td>日、一、二、三、四、五、六</td>\n</tr>\n<tr>\n<td></td>\n<td>{e}</td>\n<td>1-54</td>\n<td>1-54</td>\n</tr>\n<tr>\n<td>Hour</td>\n<td>{HH}</td>\n<td>00-23</td>\n<td>00-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{H}</td>\n<td>0-23</td>\n<td>0-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{hh}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{h}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Minute</td>\n<td>{mm}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{m}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Second</td>\n<td>{ss}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{s}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Millisecond</td>\n<td>{SSS}</td>\n<td>000-999</td>\n<td>000-999</td>\n</tr>\n<tr>\n<td></td>\n<td>{S}</td>\n<td>0-999</td>\n<td>0-999</td>\n</tr>\n</tbody>\n</table>\n<blockquote>\n<p>Templates of other languages can be found in <a href=\"https://github.com/apache/echarts/tree/master/src/i18n\" target=\"_blank\">the language package</a>. Please refer to <a href=\"api.html#echarts.registerLocale\" target=\"_blank\">echarts.registerLocale</a> to register a language.</p>\n</blockquote>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: &#39;{yyyy}-{MM}-{dd}&#39; // gets labels like &#39;2020-12-02&#39;\nformatter: &#39;Day {d}&#39; // gets labels like &#39;Day 2&#39;\n</code></pre>\n<p><strong> Callback Functions </strong></p>\n<p>Callback functions can be used to get different formats for different axis tick values. Sometimes, if you have complex date/time formatting requirement, third-party libraries like <a href=\"https://momentjs.com/\" target=\"_blank\">Moment.js</a> or <a href=\"https://date-fns.org/\" target=\"_blank\">date-fns</a> can be used to return formatted labels.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use callback function; function parameters are axis index\nformatter: function (value, index) {\n    // Formatted to be month/day; display year only in the first label\n    var date = new Date(value);\n    var texts = [(date.getMonth() + 1), date.getDate()];\n    if (idx === 0) {\n        texts.unshift(date.getYear());\n    }\n    return texts.join(&#39;/&#39;);\n}\n</code></pre>\n<p><strong> Cascading Templates </strong></p>\n<p>Sometimes, we wish to use different formats for different time granularity. For example, in a quarter-year chart, we may wish to see the month name with the first date of the month, while see the date name with others. This can be made with:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: {\n    month: &#39;{MMMM}&#39;, // Jan, Feb, ...\n    day: &#39;{d}&#39; // 1, 2, ...\n}\n</code></pre>\n<p>Supported levels and their default formatters are:</p>\n<pre><code class=\"lang-js\">{\n    year: &#39;{yyyy}&#39;,\n    month: &#39;{MMM}&#39;,\n    day: &#39;{d}&#39;,\n    hour: &#39;{HH}:{mm}&#39;,\n    minute: &#39;{HH}:{mm}&#39;,\n    second: &#39;{HH}:{mm}:{ss}&#39;,\n    millisecond: &#39;{hh}:{mm}:{ss} {SSS}&#39;,\n    none: &#39;{yyyy}-{MM}-{dd} {hh}:{mm}:{ss} {SSS}&#39;\n}\n</code></pre>\n<p>Let&#39;s take <code class=\"codespan\">day</code> for example. When a tick value is <code class=\"codespan\">0</code> for its hour, minute, second, and millisecond, <code class=\"codespan\">day</code> level will be used to make formatter. <code class=\"codespan\">none</code> is used when no other level fulfills, which is for tick values with millisecond values other than <code class=\"codespan\">0</code>.</p>\n<p><strong> Rich Text </strong></p>\n<p>The above three forms all support rich text, so it can be used to make some complex effects.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: {\n            // Display year and month information on the first data of a year\n            year: &#39;{yearStyle|{yyyy}}\\n{monthStyle|{MMM}}&#39;,\n            month: &#39;{monthStyle|{MMM}}&#39;\n        },\n        rich: {\n            yearStyle: {\n                // Make yearly text more standing out\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            monthStyle: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n<p>The above example can also be made with a callback function:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: function (value) {\n            const date = new Date(value);\n            const yearStart = new Date(value);\n            yearStart.setMonth(0);\n            yearStart.setDate(1);\n            yearStart.setHours(0);\n            yearStart.setMinutes(0);\n            yearStart.setSeconds(0);\n            yearStart.setMilliseconds(0);\n            // Whether a tick value is the start of a year\n            if (date.getTime() === yearStart.getTime()) {\n                return &#39;{year|&#39; + date.getFullYear() + &#39;}\\n&#39;\n                    + &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;;\n            }\n            else {\n                return &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;\n            }\n        },\n        rich: {\n            year: {\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            month: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n","default":null},"showMinLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the min tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the min tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"showMaxLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the max tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the max tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"color":{"type":["Color","Function"],"description":"\n\n<p>Color of axis label is set to be <a href=\"#parallelAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default. Callback function is supported, in the following format:</p>\n<pre><code class=\"lang-js\">(val: string) =&gt; Color\n</code></pre>\n<p>Parameter is the text of label, and return value is the color. See the following example:</p>\n<pre><code class=\"lang-js\">textStyle: {\n    color: function (value, index) {\n        return value &gt;= 0 ? &#39;green&#39; : &#39;red&#39;;\n    }\n}\n</code></pre>\n","uiControl":{"type":"color"}},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"data":{"type":["Array"],"description":"<p>Category data, available in <a href=\"#parallelAxis.type\">type</a>: &#39;category&#39; axis.</p>\n<p>If <a href=\"#parallelAxis.type\">type</a> is not specified, but <code class=\"codespan\">axis.data</code> is specified, the <a href=\"#parallelAxis.type\">type</a> is auto set as <code class=\"codespan\">&#39;category&#39;</code>.</p>\n<p>If <a href=\"#parallelAxis.type\">type</a> is specified as <code class=\"codespan\">&#39;category&#39;</code>, but <code class=\"codespan\">axis.data</code> is not specified, <code class=\"codespan\">axis.data</code> will be auto collected from <a href=\"#series.data\">series.data</a>. It brings convenience, but we should notice that <code class=\"codespan\">axis.data</code> provides then value range of the <code class=\"codespan\">&#39;category&#39;</code> axis. If  it is auto collected from <a href=\"#series.data\">series.data</a>, Only the values appearing in <a href=\"#series.data\">series.data</a> can be collected. For example, if <a href=\"#series.data\">series.data</a> is empty, nothing will be collected.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Name list of all categories\ndata: [&#39;Monday&#39;, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;, &#39;Friday&#39;, &#39;Saturday&#39;, &#39;Sunday&#39;]\n// Each item could also be a specific configuration item.\n// In this case, `value` is used as the category name.\ndata: [{\n    value: &#39;Monday&#39;,\n    // Highlight Monday\n    textStyle: {\n        fontSize: 20,\n        color: &#39;red&#39;\n    }\n}, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;, &#39;Friday&#39;, &#39;Saturday&#39;, &#39;Sunday&#39;]\n</code></pre>\n","items":{"type":"Object","properties":{"value":{"type":["string"],"description":"<p>Name of a category.</p>\n"},"textStyle":{"type":["Object"],"description":"<p>Text style of the category.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}},"singleAxis":{"type":["Object"],"description":"<p>An axis with a single dimension. It can be used to display data in one dimension. For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-single-axis&edit=1&reset=1\" width=\"700\" height=\"500\"></iframe>\n\n\n\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between single component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'5%'"},"top":{"type":["string","number"],"description":"<p>Distance between single component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'5%'"},"right":{"type":["string","number"],"description":"<p>Distance between single component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":"'5%'"},"bottom":{"type":["string","number"],"description":"<p>Distance between single component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":"'5%'"},"width":{"type":["string","number"],"description":"<p>Width of single component. Adaptive by default.</p>\n","default":"'auto'"},"height":{"type":["string","number"],"description":"<p>Height of single component. Adaptive by default.</p>\n","default":"'auto'"},"orient":{"type":["string"],"description":"<p>Orientation of the axis. By default, it&#39;s <code class=\"codespan\">&#39;horizontal&#39;</code>. You can set it to be <code class=\"codespan\">&#39;vertical&#39;</code> to make a vertical axis.</p>\n","default":"'horizontal'"},"type":{"type":["string"],"description":"<p>Type of axis.</p>\n<p>Option:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;value&#39;</code>\n  Numerical axis, suitable for continuous data.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;category&#39;</code>\n  Category axis, suitable for discrete category data. Category data can be auto retrieved from <a href=\"#series.data\">series.data</a> or <a href=\"#dataset.source\">dataset.source</a>, or can be specified via <a href=\"#singleAxis.data\">singleAxis.data</a>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;time&#39;</code>\n  Time axis, suitable for continuous time series data. As compared to value axis, it has a better formatting for time and a different tick calculation method. For example, it decides to use month, week, day or hour for tick based on the range of span.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;log&#39;</code>\n  Log axis, suitable for log data.</p>\n</li>\n</ul>\n","default":"'value'"},"name":{"type":["string"],"description":"\n\n<p>Name of axis.</p>\n","uiControl":{"type":"text"}},"nameLocation":{"type":["string"],"description":"\n\n<p>Location of axis name.</p>\n<p><strong>Options: </strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> or <code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","options":"start,middle,end","default":"end"},"default":"'end'"},"nameTextStyle":{"type":["Object"],"description":"<p>Text style of axis name.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Color of axis name uses <a href=\"#singleAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default.</p>\n","uiControl":{"type":"color"}},"fontStyle":{"type":["string"],"description":"\n\n<p>axis name font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p>axis name font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p>axis name font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p>axis name font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"nameGap":{"type":["number"],"description":"\n\n<p>Gap between axis name and axis line.</p>\n","uiControl":{"type":"number","step":"0.5","default":"15"},"default":15},"nameRotate":{"type":["number"],"description":"\n\n<p>Rotation of axis name.</p>\n","uiControl":{"type":"angle","min":"-360","max":"360","step":"1"},"default":null},"inverse":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> to invert the axis.\nThis is a new option available from Echarts 3 and newer.</p>\n","uiControl":{"type":"boolean"},"default":false},"boundaryGap":{"type":["boolean","Array"],"description":"\n\n<p>The boundary gap on both sides of a coordinate axis. The setting and behavior of category axes and non-category axes are different.</p>\n<p>The <code class=\"codespan\">boundaryGap</code> of category axis can be set to either <code class=\"codespan\">true</code> or <code class=\"codespan\">false</code>. Default value is set to be <code class=\"codespan\">true</code>, in which case <a href=\"#singleAxis.axisTick\">axisTick</a> is served only as a separation line, and labels and data appear only in the center part of two <a href=\"#singleAxis.axisTick\">axis ticks</a>, which is called <em>band</em>.</p>\n<p>For non-category axis, including time, numerical value, and log axes, <code class=\"codespan\">boundaryGap</code> is an array of two values, representing the spanning range between minimum and maximum value. The value can be set in numeric value or relative percentage, which becomes invalid after setting <a href=\"#singleAxis.min\">min</a> and <a href=\"#singleAxis.max\">max</a>.\n<strong>Example: </strong></p>\n<pre><code class=\"lang-js\">boundaryGap: [&#39;20%&#39;, &#39;20%&#39;]\n</code></pre>\n","uiControl":{"type":"boolean"}},"min":{"type":["number","string","Function"],"description":"\n\n<p>The minimun value of axis.</p>\n<p>It can be set to a special value <code class=\"codespan\">&#39;dataMin&#39;</code> so that the minimum value on this axis is set to be the minimum label.</p>\n<p>It will be automatically computed to make sure axis tick is equally distributed when not set.</p>\n<p>In category axis, it can also be set as the ordinal number. For example, if a catergory axis has <code class=\"codespan\">data: [&#39;categoryA&#39;, &#39;categoryB&#39;, &#39;categoryC&#39;]</code>, and the ordinal <code class=\"codespan\">2</code> represents <code class=\"codespan\">&#39;categoryC&#39;</code>. Moreover, it can be set as negative number, like <code class=\"codespan\">-3</code>.</p>\n<p>If <code class=\"codespan\">min</code> is specified as a function, it should return a min value, like:</p>\n<pre><code class=\"lang-js\">min: function (value) {\n    return value.min - 20;\n}\n</code></pre>\n<p><code class=\"codespan\">value</code> is an object, containing the <code class=\"codespan\">min</code> value and <code class=\"codespan\">max</code> value of the data. This function should return the min value of axis, or return <code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> to make echarts use the auto calculated min value (<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> return is only supported since <code class=\"codespan\">v4.8.0</code>).</p>\n","uiControl":{"type":"number"},"default":null},"max":{"type":["number","string","Function"],"description":"\n\n<p>The maximum value of axis.</p>\n<p>It can be set to a special value <code class=\"codespan\">&#39;dataMax&#39;</code> so that the minimum value on this axis is set to be the maximum label.</p>\n<p>It will be automatically computed to make sure axis tick is equally distributed when not set.</p>\n<p>In category axis, it can also be set as the ordinal number. For example, if a catergory axis has <code class=\"codespan\">data: [&#39;categoryA&#39;, &#39;categoryB&#39;, &#39;categoryC&#39;]</code>, and the ordinal <code class=\"codespan\">2</code> represents <code class=\"codespan\">&#39;categoryC&#39;</code>. Moreover, it can be set as negative number, like <code class=\"codespan\">-3</code>.</p>\n<p>If <code class=\"codespan\">max</code> is specified as a function, it should return a max value, like:</p>\n<pre><code class=\"lang-js\">max: function (value) {\n    return value.max - 20;\n}\n</code></pre>\n<p><code class=\"codespan\">value</code> is an object, containing the <code class=\"codespan\">min</code> value and <code class=\"codespan\">max</code> value of the data. This function should return the max value of axis, or return <code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> to make echarts use the auto calculated max value (<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> return is only supported since <code class=\"codespan\">v4.8.0</code>).</p>\n","uiControl":{"type":"number"},"default":null},"scale":{"type":["boolean"],"description":"\n\n<p>It is available only in numerical axis, i.e., <a href=\"#singleAxis.type\">type</a>: &#39;value&#39;.</p>\n<p>It specifies whether not to contain zero position of axis compulsively. When it is set to be <code class=\"codespan\">true</code>, the axis may not contain zero position, which is useful in the scatter chart for both value axes.</p>\n<p>This configuration item is unavailable when the <a href=\"#singleAxis.min\">min</a> and <a href=\"#singleAxis.max\">max</a> are set.</p>\n","uiControl":{"type":"boolean"},"default":false},"splitNumber":{"type":["number"],"description":"\n\n<p>Number of segments that the axis is split into. Note that this number serves only as a recommendation, and the true segments may be adjusted based on readability.</p>\n<p>This is unavailable for category axis.</p>\n","uiControl":{"type":"number","min":"1","step":"1","default":"5"},"default":5},"minInterval":{"type":["number"],"description":"\n\n<p>Minimum gap between split lines.</p>\n<p>For example, it can be set to be <code class=\"codespan\">1</code> to make sure axis label is show as integer.</p>\n<pre><code class=\"lang-js\">{\n    minInterval: 1\n}\n</code></pre>\n<p>It is available only for axis of <a href=\"#singleAxis.type\">type</a> &#39;value&#39; or &#39;time&#39;.</p>\n","uiControl":{"type":"number"},"default":0},"maxInterval":{"type":["number"],"description":"\n\n<p>Maximum gap between split lines.</p>\n<p>For example, in time axis (<a href=\"#singleAxis.type\">type</a> is &#39;time&#39;), it can be set to be <code class=\"codespan\">3600 * 24 * 1000</code> to make sure that the gap between axis labels is less than or equal to one day.</p>\n<pre><code class=\"lang-js\">{\n    maxInterval: 3600 * 1000 * 24\n}\n</code></pre>\n<p>It is available only for axis of <a href=\"#singleAxis.type\">type</a> &#39;value&#39; or &#39;time&#39;.</p>\n","uiControl":{"type":"number"}},"interval":{"type":["number"],"description":"\n\n<p>Compulsively set segmentation interval for axis.</p>\n<p>As <a href=\"#singleAxis.splitNumber\">splitNumber</a> is a recommendation value, the calculated tick may not be the same as expected. In this case, interval should be used along with <a href=\"#singleAxis.min\">min</a> and <a href=\"#singleAxis.max\">max</a> to compulsively set tickings. But in most cases, we do not suggest using this, out automatic calculation is enough for most situations.</p>\n<p>This is unavailable for category axis. Timestamp should be passed for <a href=\"#singleAxis.type\">type</a>: &#39;time&#39; axis. Logged value should be passed for <a href=\"#singleAxis.type\">type</a>: &#39;log&#39; axis.</p>\n","uiControl":{"type":"number"}},"logBase":{"type":["number"],"description":"\n\n<p>Base of logarithm, which is valid only for numeric axes with <a href=\"#singleAxis.type\">type</a>: &#39;log&#39;.</p>\n","uiControl":{"type":"number","default":"10"},"default":10},"silent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code>, to prevent interaction with the axis.</p>\n","default":false},"triggerEvent":{"type":["boolean"],"description":"<p>Set this to <code class=\"codespan\">true</code> to enable triggering events.</p>\n<p>Parameters of the event include:</p>\n<pre><code class=\"lang-js\">{\n    // Component type: xAxis, yAxis, radiusAxis, angleAxis\n    // Each of which has an attribute for index, e.g., xAxisIndex for xAxis\n    componentType: string,\n    // Value on axis before being formatted.\n    // Click on value label to trigger event.\n    value: &#39;&#39;,\n    // Name of axis.\n    // Click on laben name to trigger event.\n    name: &#39;&#39;\n}\n</code></pre>\n","default":false},"axisLine":{"type":["Object"],"description":"<p>Settings related to axis line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis line from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"symbol":{"type":["string","Array"],"description":"\n\n<p>Symbol of the two ends of the axis. It could be a string, representing the same symbol for two ends; or an array with two string elements, representing the two ends separately. It&#39;s set to be <code class=\"codespan\">&#39;none&#39;</code> by default, meaning no arrow for either end. If it is set to be <code class=\"codespan\">&#39;arrow&#39;</code>, there shall be two arrows. If there should only one arrow at the end, it should set to be <code class=\"codespan\">[&#39;none&#39;, &#39;arrow&#39;]</code>.</p>\n","uiControl":{"type":"icon","default":"none"},"default":"'none'"},"symbolSize":{"type":["Array"],"description":"\n\n<p>Size of the arrows at two ends. The first is the width perpendicular to the axis, the next is the width parallel to the axis.</p>\n","uiControl":{"type":"vector","default":"10,15"},"default":"[10, 15]"},"symbolOffset":{"type":["Array","number"],"description":"\n\n<p>Arrow offset of axis. If is array, the first number is the offset of the arrow at the beginning, and the second number is the offset of the arrow at the end. If is number, it means the arrows have the same offset.</p>\n","uiControl":{"type":"vector","default":"0,0"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>line styleLine color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#333'"},"width":{"type":["number"],"description":"\n\n<p>line style line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>line style line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisTick":{"type":["Object"],"description":"<p>Settings related to axis tick.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis tick from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"alignWithLabel":{"type":["boolean"],"description":"\n\n<p>Align axis tick with label, which is available only when <code class=\"codespan\">boundaryGap</code> is set to be <code class=\"codespan\">true</code> in category axis. See the following picture:</p>\n<p><img width=\"600\" height=\"auto\" src=\"documents/asset/img/axis-align-with-label.png\"></p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of axisTick, which is available in category axis.  is set to be the same as <a href=\"#singleAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"inside":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> so the axis labels face the <code class=\"codespan\">inside</code> direction.</p>\n","uiControl":{"type":"boolean"},"default":false},"length":{"type":["number"],"description":"\n\n<p>The length of the axis tick.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"5"},"default":5},"lineStyle":{"type":["Object"],"description":"<p>Line style of axis ticks.</p>\n","properties":{"color":{"type":["Color"],"description":"<p>Color of axis label is set to be <a href=\"#singleAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default.</p>\n"},"width":{"type":["number"],"description":"\n\n<p>axisTick line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>axisTick line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"minorTick":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.6.0</code></p>\n</blockquote>\n<p>Settings related minor ticks.</p>\n<p>Note: <code class=\"codespan\">minorTick</code> is not available in the <code class=\"codespan\">category</code> type axis.</p>\n<p>Examples:</p>\n<p>1) Using minor ticks in function plotting.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-function&edit=1&reset=1\" width=\"600\" height=\"350\"></iframe>\n\n\n<p>2) Using minor ticks in log axis.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-log&edit=1&reset=1\" width=\"600\" height=\"350\"></iframe>\n\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>If show minor ticks.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"splitNumber":{"type":["number"],"description":"\n\n<p>Number of interval splited by minor ticks.</p>\n","uiControl":{"type":"number","min":"1","step":"1","default":"5"},"default":5},"length":{"type":["number"],"description":"\n\n<p>Length of minor ticks lines。</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"3"},"default":3},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Style configuration of minor ticks lines <a href=\"#singleAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a>。</p>\n","uiControl":{"type":"color"}},"width":{"type":["number"],"description":"\n\n<p>minorTick line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>minorTick line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisLabel":{"type":["Object"],"description":"<p>Settings related to axis label.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the axis label from appearing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis label, which is available in category axis. </p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"inside":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> so the axis labels face the <code class=\"codespan\">inside</code> direction.</p>\n","uiControl":{"type":"boolean"},"default":false},"rotate":{"type":["number"],"description":"\n\n<p>Rotation degree of axis label, which is especially useful when there is no enough space for category axis.</p>\n<p>Rotation degree is from -90 to 90.</p>\n","uiControl":{"type":"angle","min":"-90","max":"90","step":"1"},"default":0},"margin":{"type":["number"],"description":"\n\n<p>The margin between the axis label and the axis line.</p>\n","uiControl":{"type":"number","default":"8","step":"0.5"},"default":8},"formatter":{"type":["string","Function"],"description":"<p>Formatter of axis label, which supports string template and callback function.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use string template; template variable is the default label of axis {value}\nformatter: &#39;{value} kg&#39;\n// Use callback.\nformatter: function (value, index) {\n    return value + &#39;kg&#39;;\n}\n</code></pre>\n<hr>\n<p>For axes of time <a href=\"#.type\">type</a>: <code class=\"codespan\">&#39;time&#39;</code>, <code class=\"codespan\">formatter</code> supports the following forms:</p>\n<ul>\n<li><strong>String Templates</strong>: an easy and fast way to make frequently used date/time template, formed in <code class=\"codespan\">string</code></li>\n<li><strong>Callback Functions</strong>: customized formatter to make complex format, formed in <code class=\"codespan\">Function</code></li>\n<li><strong>Cascading Templates</strong>: to adopt different formatters for different time granularity, formed in <code class=\"codespan\">object</code></li>\n</ul>\n<p>Next, we are going to introduce these three forms one by one.</p>\n<p><strong> String Templates </strong></p>\n<p>Using string templates is an easy way to format date/time with frequently used formats. If it can be used to make what you want, you are advised to do so. If not, you could then consider the others. Supported formats are:</p>\n<table>\n<thead>\n<tr>\n<th>Group</th>\n<th>Template</th>\n<th>Value (EN)</th>\n<th>Value (ZH)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Year</td>\n<td>{yyyy}</td>\n<td>e.g., 2020, 2021, ...</td>\n<td>例：2020, 2021, ...</td>\n</tr>\n<tr>\n<td></td>\n<td>{yy}</td>\n<td>00-99</td>\n<td>00-99</td>\n</tr>\n<tr>\n<td>Quarter</td>\n<td>{Q}</td>\n<td>1, 2, 3, 4</td>\n<td>1, 2, 3, 4</td>\n</tr>\n<tr>\n<td>Month</td>\n<td>{MMMM}</td>\n<td>e.g., January, February, ...</td>\n<td>一月、二月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MMM}</td>\n<td>e.g., Jan, Feb, ...</td>\n<td>1月、2月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MM}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{M}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Day of Month</td>\n<td>{dd}</td>\n<td>01-31</td>\n<td>01-31</td>\n</tr>\n<tr>\n<td></td>\n<td>{d}</td>\n<td>1-31</td>\n<td>1-31</td>\n</tr>\n<tr>\n<td>Day of Week</td>\n<td>{eeee}</td>\n<td>Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday</td>\n<td>星期日、星期一、星期二、星期三、星期四、星期五、星期六</td>\n</tr>\n<tr>\n<td></td>\n<td>{ee}</td>\n<td>Sun, Mon, Tues, Wed, Thu, Fri, Sat</td>\n<td>日、一、二、三、四、五、六</td>\n</tr>\n<tr>\n<td></td>\n<td>{e}</td>\n<td>1-54</td>\n<td>1-54</td>\n</tr>\n<tr>\n<td>Hour</td>\n<td>{HH}</td>\n<td>00-23</td>\n<td>00-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{H}</td>\n<td>0-23</td>\n<td>0-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{hh}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{h}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Minute</td>\n<td>{mm}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{m}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Second</td>\n<td>{ss}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{s}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Millisecond</td>\n<td>{SSS}</td>\n<td>000-999</td>\n<td>000-999</td>\n</tr>\n<tr>\n<td></td>\n<td>{S}</td>\n<td>0-999</td>\n<td>0-999</td>\n</tr>\n</tbody>\n</table>\n<blockquote>\n<p>Templates of other languages can be found in <a href=\"https://github.com/apache/echarts/tree/master/src/i18n\" target=\"_blank\">the language package</a>. Please refer to <a href=\"api.html#echarts.registerLocale\" target=\"_blank\">echarts.registerLocale</a> to register a language.</p>\n</blockquote>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: &#39;{yyyy}-{MM}-{dd}&#39; // gets labels like &#39;2020-12-02&#39;\nformatter: &#39;Day {d}&#39; // gets labels like &#39;Day 2&#39;\n</code></pre>\n<p><strong> Callback Functions </strong></p>\n<p>Callback functions can be used to get different formats for different axis tick values. Sometimes, if you have complex date/time formatting requirement, third-party libraries like <a href=\"https://momentjs.com/\" target=\"_blank\">Moment.js</a> or <a href=\"https://date-fns.org/\" target=\"_blank\">date-fns</a> can be used to return formatted labels.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use callback function; function parameters are axis index\nformatter: function (value, index) {\n    // Formatted to be month/day; display year only in the first label\n    var date = new Date(value);\n    var texts = [(date.getMonth() + 1), date.getDate()];\n    if (idx === 0) {\n        texts.unshift(date.getYear());\n    }\n    return texts.join(&#39;/&#39;);\n}\n</code></pre>\n<p><strong> Cascading Templates </strong></p>\n<p>Sometimes, we wish to use different formats for different time granularity. For example, in a quarter-year chart, we may wish to see the month name with the first date of the month, while see the date name with others. This can be made with:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: {\n    month: &#39;{MMMM}&#39;, // Jan, Feb, ...\n    day: &#39;{d}&#39; // 1, 2, ...\n}\n</code></pre>\n<p>Supported levels and their default formatters are:</p>\n<pre><code class=\"lang-js\">{\n    year: &#39;{yyyy}&#39;,\n    month: &#39;{MMM}&#39;,\n    day: &#39;{d}&#39;,\n    hour: &#39;{HH}:{mm}&#39;,\n    minute: &#39;{HH}:{mm}&#39;,\n    second: &#39;{HH}:{mm}:{ss}&#39;,\n    millisecond: &#39;{hh}:{mm}:{ss} {SSS}&#39;,\n    none: &#39;{yyyy}-{MM}-{dd} {hh}:{mm}:{ss} {SSS}&#39;\n}\n</code></pre>\n<p>Let&#39;s take <code class=\"codespan\">day</code> for example. When a tick value is <code class=\"codespan\">0</code> for its hour, minute, second, and millisecond, <code class=\"codespan\">day</code> level will be used to make formatter. <code class=\"codespan\">none</code> is used when no other level fulfills, which is for tick values with millisecond values other than <code class=\"codespan\">0</code>.</p>\n<p><strong> Rich Text </strong></p>\n<p>The above three forms all support rich text, so it can be used to make some complex effects.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: {\n            // Display year and month information on the first data of a year\n            year: &#39;{yearStyle|{yyyy}}\\n{monthStyle|{MMM}}&#39;,\n            month: &#39;{monthStyle|{MMM}}&#39;\n        },\n        rich: {\n            yearStyle: {\n                // Make yearly text more standing out\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            monthStyle: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n<p>The above example can also be made with a callback function:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: function (value) {\n            const date = new Date(value);\n            const yearStart = new Date(value);\n            yearStart.setMonth(0);\n            yearStart.setDate(1);\n            yearStart.setHours(0);\n            yearStart.setMinutes(0);\n            yearStart.setSeconds(0);\n            yearStart.setMilliseconds(0);\n            // Whether a tick value is the start of a year\n            if (date.getTime() === yearStart.getTime()) {\n                return &#39;{year|&#39; + date.getFullYear() + &#39;}\\n&#39;\n                    + &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;;\n            }\n            else {\n                return &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;\n            }\n        },\n        rich: {\n            year: {\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            month: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n","default":null},"showMinLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the min tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the min tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"showMaxLabel":{"type":["boolean"],"description":"\n\n<p>Whether to show the label of the max tick. Optional values: <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>, <code class=\"codespan\">null</code>. It is auto determined by default, that is, if labels are overlapped, the label of the max tick will not be displayed.</p>\n","uiControl":{"type":"boolean"},"default":null},"color":{"type":["Color","Function"],"description":"\n\n<p>Color of axis label is set to be <a href=\"#singleAxis.axisLine.lineStyle.color\">axisLine.lineStyle.color</a> by default. Callback function is supported, in the following format:</p>\n<pre><code class=\"lang-js\">(val: string) =&gt; Color\n</code></pre>\n<p>Parameter is the text of label, and return value is the color. See the following example:</p>\n<pre><code class=\"lang-js\">textStyle: {\n    color: function (value, index) {\n        return value &gt;= 0 ? &#39;green&#39; : &#39;red&#39;;\n    }\n}\n</code></pre>\n","uiControl":{"type":"color"}},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"splitLine":{"type":["Object"],"description":"<p>Split line of axis in <a href=\"#grid\">grid</a> area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the splitLine from showing.\n<code class=\"codespan\">value</code> type axes are shown by default, while <code class=\"codespan\">category</code> type axes are hidden.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis splitLine, which is available in category axis.  is set to be the same as <a href=\"#singleAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Array","string"],"description":"\n\n<p>The color of the splitLine, which could be set separately.</p>\n<p>SplitLine color could also be set in color array, which the split lines would take as their colors in turns.</p>\n<p>Example:</p>\n<pre><code>splitLine: {\n    lineStyle: {\n        // Dark and light colors will be used in turns\n        color: [&#39;#aaa&#39;, &#39;#ddd&#39;]\n    }\n}\n</code></pre>","uiControl":{"type":"color"},"default":"['#ccc']"},"width":{"type":["number"],"description":"\n\n<p>splitLine line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>splitLine line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"minorSplitLine":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.6.0</code></p>\n</blockquote>\n<p>Minor split lines of axis in the <a href=\"#grid\">grid</a> area。It will align to the <a href=\"#singleAxis.minorTick\">minorTick</a></p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>If show minor split lines.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>minorSplitLineLine color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#eee'"},"width":{"type":["number"],"description":"\n\n<p>minorSplitLine line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>minorSplitLine line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"splitArea":{"type":["Object"],"description":"<p>Split area of axis in <a href=\"#grid\">grid</a> area, not shown by default.</p>\n","properties":{"interval":{"type":["number","Function"],"description":"\n\n\n\n<p>Interval of Axis splitArea, which is available in category axis.  is set to be the same as <a href=\"#singleAxis.axisLabel.interval\">axisLabel.interval</a> by default.</p>\n<p>It uses a strategy that labels do not overlap by default.</p>\n<p>You may set it to be 0 to display all labels compulsively.</p>\n<p>If it is set to be 1, it means that labels are shown once after one label. And if it is set to be 2, it means labels are shown once after two labels, and so on.</p>\n<p>On the other hand, you can control by callback function, whose format is shown below:</p>\n<pre><code class=\"lang-js\">(index:number, value: string) =&gt; boolean\n</code></pre>\n<p>The first parameter is index of category, and the second parameter is the name of category. The return values decides whether to display label.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"'auto'"},"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">true</code> to show the splitArea.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"areaStyle":{"type":["Object"],"description":"<p>Split area style.</p>\n","properties":{"color":{"type":["Array"],"description":"<p>Color of split area.\nSplitArea color could also be set in color array, which the split lines would take as their colors in turns. Dark and light colors in turns are used by default.</p>\n","default":"['rgba(250,250,250,0.3)','rgba(200,200,200,0.3)']"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Category data, available in <a href=\"#singleAxis.type\">type</a>: &#39;category&#39; axis.</p>\n<p>If <a href=\"#singleAxis.type\">type</a> is not specified, but <code class=\"codespan\">axis.data</code> is specified, the <a href=\"#singleAxis.type\">type</a> is auto set as <code class=\"codespan\">&#39;category&#39;</code>.</p>\n<p>If <a href=\"#singleAxis.type\">type</a> is specified as <code class=\"codespan\">&#39;category&#39;</code>, but <code class=\"codespan\">axis.data</code> is not specified, <code class=\"codespan\">axis.data</code> will be auto collected from <a href=\"#series.data\">series.data</a>. It brings convenience, but we should notice that <code class=\"codespan\">axis.data</code> provides then value range of the <code class=\"codespan\">&#39;category&#39;</code> axis. If  it is auto collected from <a href=\"#series.data\">series.data</a>, Only the values appearing in <a href=\"#series.data\">series.data</a> can be collected. For example, if <a href=\"#series.data\">series.data</a> is empty, nothing will be collected.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Name list of all categories\ndata: [&#39;Monday&#39;, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;, &#39;Friday&#39;, &#39;Saturday&#39;, &#39;Sunday&#39;]\n// Each item could also be a specific configuration item.\n// In this case, `value` is used as the category name.\ndata: [{\n    value: &#39;Monday&#39;,\n    // Highlight Monday\n    textStyle: {\n        fontSize: 20,\n        color: &#39;red&#39;\n    }\n}, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;, &#39;Friday&#39;, &#39;Saturday&#39;, &#39;Sunday&#39;]\n</code></pre>\n","items":{"type":"Object","properties":{"value":{"type":["string"],"description":"<p>Name of a category.</p>\n"},"textStyle":{"type":["Object"],"description":"<p>Text style of the category.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}},"axisPointer":{"type":["Object"],"description":"<p>axisPointer settings on the axis.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>axisPointer will not be displayed by default. But if <a href=\"#tooltip.trigger\">tooltip.trigger</a> is set as <code class=\"codespan\">&#39;axis&#39;</code> or <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, axisPointer will be displayed automatically. Each coordinate system will automatically chose the axes whose will display its axisPointer. <a href=\"#tooltip.axisPointer.axis\">tooltip.axisPointer.axis</a> can be used to change the choice.</p>\n","uiControl":{"type":"boolean"},"default":false},"type":{"type":["string"],"description":"\n\n<p>Indicator type.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;line&#39;</code> line indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;shadow&#39;</code> shadow crosshair indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code> no indicator displayed.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"line,shadow,none"},"default":"'line'"},"snap":{"type":["boolean"],"description":"<p>Whether snap to point automatically. The default value is auto determined.</p>\n<p>This feature usually makes sense in value axis and time axis, where tiny points can be seeked automatically.</p>\n"},"z":{"type":["number"],"description":"<p>z value, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n"},"label":{"type":["Object"],"description":"<p>label of axisPointer</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label. Label will not show by default. But if <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, label will be displayed automatically.</p>\n","default":false},"precision":{"type":["number","string"],"description":"<p>The precision of value in label. It is auto determined by default. You can also set it as <code class=\"codespan\">&#39;2&#39;</code>, which indicates that two decimal fractions are reserved.</p>\n","default":"'auto'"},"formatter":{"type":["string","Function"],"description":"<p>The formatter of label.</p>\n<p>If set as <code class=\"codespan\">string</code>, for example it can be: <code class=\"codespan\">formatter: &#39;some text {value} some text</code>, where <code class=\"codespan\">{value}</code> will be replaced by axis value automatically.</p>\n<p>If set as <code class=\"codespan\">function</code>:</p>\n<p><strong>Parameters:</strong></p>\n<p><code class=\"codespan\">{Object}</code> params: Including fields as follows:</p>\n<p><code class=\"codespan\">{Object}</code> params.value: current value of this axis. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;category&#39;</code>, it is one of the value in <code class=\"codespan\">axis.data</code>. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;time&#39;</code>, it is a timestamp.</p>\n<p><code class=\"codespan\">{Array.&lt;Object&gt;}</code> params.seriesData: An array, containing info of nearest points. Each item is:</p>\n<p><code class=\"codespan\">{string}</code> params.axisDimension: The dimension name of the axis. For example, in catesian it will be <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, and in polar it will be <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code>.</p>\n<p><code class=\"codespan\">{number}</code> params.axisIndex: The index of the axis, for example, <code class=\"codespan\">0</code>,<code class=\"codespan\">1</code>, <code class=\"codespan\">2</code>, ...</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>Each item also includes axis infomation:</p>\n<pre><code class=\"lang-js\">{\n    axisDim: &#39;x&#39;, // &#39;x&#39;, &#39;y&#39;, &#39;angle&#39;, &#39;radius&#39;, &#39;single&#39;\n    axisId: &#39;xxx&#39;,\n    axisName: &#39;xxx&#39;,\n    axisIndex: 3,\n    axisValue: 121, // The current value of axisPointer\n    axisValueLabel: &#39;text of value&#39;\n}\n</code></pre>\n<p><strong>Return:</strong></p>\n<p>The string to be displayed.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">formatter: function (params) {\n    // If axis.type is &#39;time&#39;\n    return &#39;some text&#39; + echarts.format.formatTime(params.value);\n}\n</code></pre>\n","default":null},"margin":{"type":["boolean"],"description":"<p>Distance between label and axis.</p>\n","default":3},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"padding":{"type":["string","Array"],"description":"\n\n<p>axisPointer space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":"[5, 7, 5, 7]"},"backgroundColor":{"type":["string"],"description":"<p>Background color of label, the same as <a href=\"#xAxis.axisLine.lineStyle.color\">axis.axisLine.lineStyle.color</a> by default.</p>\n","default":"'auto'"},"borderColor":{"type":["string"],"description":"<p>Border color of label.</p>\n","default":null},"borderWidth":{"type":["string"],"description":"<p>Border width of label.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"lineStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;line&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#555"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"shadowStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;shadow&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'rgba(150,150,150,0.3)"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"triggerTooltip":{"type":["boolean"],"description":"\n\n<p>Whether to trigger tooltip.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"value":{"type":["number"],"description":"<p>current value. When using <a href=\"xAxisPointer.handle\" target=\"_blank\">axisPointer.handle</a>, <code class=\"codespan\">value</code> can be set to define the initail position of axisPointer.</p>\n","default":null},"status":{"type":["boolean"],"description":"\n\n<p>Current status, can be <code class=\"codespan\">&#39;show&#39;</code> 和 <code class=\"codespan\">&#39;hide&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"show,hide"}},"handle":{"type":["Object"],"description":"<p>A button used to drag axisPointer. This feature is applicable in touch device. See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-tooltip-touch&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set to <code class=\"codespan\">true</code> to use handle.</p>\n","uiControl":{"type":"boolean"},"default":false},"icon":{"type":["*"],"description":"\n\n<p>The icon of the handle.</p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/axisPointer-handle-image&amp;edit=1&amp;reset=1\" target=\"_blank\">example of using image</a></p>\n","uiControl":{"type":"icon","clean":"true"}},"size":{"type":["number","Array"],"description":"\n\n<p>The size of the handle, which can be set as a single value or an array (<code class=\"codespan\">[width, height]</code>).</p>\n","uiControl":{"type":"vector","default":"45,45","min":"0","step":"0.5","dims":"width,height"},"default":45},"margin":{"type":["number"],"description":"\n\n<p>Distance from handle center to axis.</p>\n","uiControl":{"type":"number","default":"50","min":"0","step":"0.5"},"default":50},"color":{"type":["string"],"description":"\n\n<p>The color of the handle.</p>\n","uiControl":{"type":"color"},"default":"'#333'"},"throttle":{"type":["number"],"description":"\n\n<p>Throttle rate of trigger view update when dragging handle, in ms. Increase the value to improve performance, but decrease the experience.</p>\n","uiControl":{"type":"number","default":"40","min":"0","step":"10"},"default":40},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"2","step":"0.5"},"default":2},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}}}},"tooltip":{"type":["Object"],"description":"<p>tooltip settings in the coordinate system component.</p>\n<hr>\n<p><strong>General Introduction:</strong></p>\n<p>tooltip can be configured on different places:</p>\n<ul>\n<li><p>Configured on global: <a href=\"#tooltip\">tooltip</a></p>\n</li>\n<li><p>Configured in a coordinate system: <a href=\"#grid.tooltip\">grid.tooltip</a>, <a href=\"#polar.tooltip\">polar.tooltip</a>, <a href=\"#single.tooltip\">single.tooltip</a></p>\n</li>\n<li><p>Configured in a series: <a href=\"#series.tooltip\">series.tooltip</a></p>\n</li>\n<li><p>Configured in each item of <code class=\"codespan\">series.data</code>: <a href=\"#series.data.tooltip\">series.data.tooltip</a></p>\n</li>\n</ul>\n<hr>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the tooltip component, including tooltip floating layer and <a href=\"#tooltip.axisPointer\">axisPointer</a>.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"trigger":{"type":["string"],"description":"\n\n<p>Type of triggering.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;item&#39;</code></p>\n<p>  Triggered by data item, which is mainly used for charts that don&#39;t have a category axis like scatter charts or pie charts.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;axis&#39;</code></p>\n<p>  Triggered by axes, which is mainly used for charts that have category axes, like bar charts or line charts.</p>\n<p> ECharts 2.x only supports axis trigger for category axis. In ECharts 3, it is supported for all types of axes in <a href=\"#grid\">grid</a> or <a href=\"#polar\">polar</a>. Also, you may assign axis with <a href=\"#tooltip.axisPointer.axis\">axisPointer.axis</a>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code></p>\n<p>  Trigger nothing.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"item,axis,none","default":"item"},"default":"'item'"},"axisPointer":{"type":["Object"],"description":"<p>Configuration item for axisPointer.</p>\n<p><code class=\"codespan\">tooltip.axisPointer</code> is like syntactic sugar of axisPointer settings on axes (for example, <a href=\"#xAxis.axisPointer\">xAxis.axisPointer</a> or <a href=\"#angleAxis.axisPointer\">angleAxis.axisPointer</a>). More detailed features can be configured on <code class=\"codespan\">someAxis.axisPointer</code>. But in common cases, using <code class=\"codespan\">tooltip.axisPointer</code> is more convenient.</p>\n<blockquote>\n<p><strong>Notice:</strong> configurations of <code class=\"codespan\">tooltip.axisPointer</code> has lower priority than that of <code class=\"codespan\">someAxis.axisPointer</code>.</p>\n</blockquote>\n<hr>\n<p><code class=\"codespan\">axisPointer</code> is a tool for displaying reference line and axis value under mouse pointer.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/candlestick-axisPointer&edit=1&reset=1\" width=\"600\" height=\"450\"></iframe>\n\n\n<p>In the demo above, <a href=\"#axisPointer.link\">axisPointer.link</a> is used to link axisPointer from different coordinate systems.</p>\n<p><code class=\"codespan\">axisPointer</code> can also be used on touch device, where user can drag the button to move the reference line and label.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-tooltip-touch&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n<p>In the cases that more than one axis exist, axisPointer helps to look inside the data.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=multiple-y-axis&edit=1&reset=1\" width=\"600\" height=\"300\"></iframe>\n\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=multiple-x-axis&edit=1&reset=1\" width=\"600\" height=\"300\"></iframe>\n\n\n\n<hr>\n<blockquote>\n<p><strong>Notice:</strong>\nGenerally, axisPointers is configured in each axes who need them (for example <a href=\"#xAxis.axisPointer\">xAxis.axisPointer</a>), or configured in <code class=\"codespan\">tooltip</code> (for example <a href=\"#tooltip.axisPointer\">tooltip.axisPointer</a>).</p>\n</blockquote>\n<blockquote>\n<p>But these configurations can only be configured in global axisPointer:\n<a href=\"#axisPointer.triggerOn\">axisPointer.triggerOn</a>, <a href=\"#axisPointer.link\">axisPointer.link</a>.</p>\n</blockquote>\n<hr>\n<hr>\n<p><strong>How to display axisPointer:</strong></p>\n<p>In <a href=\"#grid\">cartesian (grid)</a> and <a href=\"#single\">polar](~polar) and (single axis</a>, each axis has its own axisPointer.</p>\n<p>Those axisPointer will not be displayed by default, utill configured as follows:</p>\n<ul>\n<li><p>Set <code class=\"codespan\">someAxis.axisPointer.show</code> (like <a href=\"#xAxis.axisPointer.show\">xAxis.axisPointer.show</a>) as <code class=\"codespan\">true</code>. Then axisPointer of this axis will be displayed.</p>\n</li>\n<li><p>Set <a href=\"#tooltip.trigger\">tooltip.trigger</a> as <code class=\"codespan\">&#39;axis&#39;</code>, or set <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> as <code class=\"codespan\">&#39;cross&#39;</code>. Then coordinate system will automatically chose the axes who will display their axisPointers. (<a href=\"#tooltip.axisPointer.axis\">tooltip.axisPointer.axis</a> can be used to change the choice.) Notice, <code class=\"codespan\">axis.axisPointer</code> will override <code class=\"codespan\">tooltip.axisPointer</code> settings.</p>\n</li>\n</ul>\n<hr>\n<p><strong>How to display the label of axisPointer:</strong></p>\n<p>The label of axisPointer will not be displayed by default(namely, only reference line will be displayed by default), utill configured as follows:</p>\n<ul>\n<li><p>Set <code class=\"codespan\">someAxis.axisPointer.label.show</code> (for example <a href=\"#xAxis.axisPointer.show\">xAxis.axisPointer.label.show</a>) as <code class=\"codespan\">true</code>. Then the label of the axisPointer will be displayed.</p>\n</li>\n<li><p>Set <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> as  <code class=\"codespan\">&#39;cross&#39;</code>. Then the label of the crossed axisPointers will be displayed.</p>\n</li>\n</ul>\n<hr>\n<p><strong>How to configure axisPointer on touch device:</strong></p>\n<p>Set <code class=\"codespan\">someAxis.axisPointer.handle.show</code> (for example <a href=\"#xAxis.axisPointer.handle.show\">xAxis.axisPointer.handle.show</a> as <code class=\"codespan\">true</code>. Then the button for dragging will be displayed. (This feature is not supported on polar).</p>\n<p><strong>Notice:</strong>\nIf tooltip does not work well in this case, try to set<a href=\"#tooltip.triggerOn\">tooltip.triggerOn</a> as <code class=\"codespan\">&#39;none&#39;</code> (for the effect: show tooltip when finger holding on the button, and hide tooltip after finger left the button), or set <a href=\"#tooltip.alwaysShowContent\">tooltip.alwaysShowContent</a> as <code class=\"codespan\">true</code> (then tooltip will always be displayed).</p>\n<p>See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-tooltip-touch&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>.</p>\n<hr>\n<p><strong>Snap to point</strong></p>\n<p>In value axis and time axis, if <a href=\"#xAxis.axisPointer.snap\">snap</a> is set as true, axisPointer will snap to point automatically.</p>\n<hr>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Indicator type.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;line&#39;</code> line indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;shadow&#39;</code> shadow crosshair indicator.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;none&#39;</code> no indicator displayed.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;cross&#39;</code> crosshair indicator, which is actually the shortcut of enable two axisPointers of two orthometric axes.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"none,line,shadow,cross","default":"line"},"default":"'line'"},"axis":{"type":["string"],"description":"<p>The coordinate axis, which could be <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, <code class=\"codespan\">&#39;radius&#39;</code>, or <code class=\"codespan\">&#39;angle&#39;</code>. By default, each coordinate system will automatically chose the axes whose will display its axisPointer (category axis or time axis is used by default).</p>\n","default":"'auto'"},"snap":{"type":["boolean"],"description":"<p>Whether snap to point automatically. The default value is auto determined.</p>\n<p>This feature usually makes sense in value axis and time axis, where tiny points can be seeked automatically.</p>\n"},"z":{"type":["number"],"description":"<p>z value, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n"},"label":{"type":["Object"],"description":"<p>label of axisPointer</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label. Label will not show by default. But if <a href=\"#tooltip.axisPointer.type\">tooltip.axisPointer.type</a> is set as  <code class=\"codespan\">&#39;cross&#39;</code>, label will be displayed automatically.</p>\n","default":false},"precision":{"type":["number","string"],"description":"<p>The precision of value in label. It is auto determined by default. You can also set it as <code class=\"codespan\">&#39;2&#39;</code>, which indicates that two decimal fractions are reserved.</p>\n","default":"'auto'"},"formatter":{"type":["string","Function"],"description":"<p>The formatter of label.</p>\n<p>If set as <code class=\"codespan\">string</code>, for example it can be: <code class=\"codespan\">formatter: &#39;some text {value} some text</code>, where <code class=\"codespan\">{value}</code> will be replaced by axis value automatically.</p>\n<p>If set as <code class=\"codespan\">function</code>:</p>\n<p><strong>Parameters:</strong></p>\n<p><code class=\"codespan\">{Object}</code> params: Including fields as follows:</p>\n<p><code class=\"codespan\">{Object}</code> params.value: current value of this axis. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;category&#39;</code>, it is one of the value in <code class=\"codespan\">axis.data</code>. If <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;time&#39;</code>, it is a timestamp.</p>\n<p><code class=\"codespan\">{Array.&lt;Object&gt;}</code> params.seriesData: An array, containing info of nearest points. Each item is:</p>\n<p><code class=\"codespan\">{string}</code> params.axisDimension: The dimension name of the axis. For example, in catesian it will be <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, and in polar it will be <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code>.</p>\n<p><code class=\"codespan\">{number}</code> params.axisIndex: The index of the axis, for example, <code class=\"codespan\">0</code>,<code class=\"codespan\">1</code>, <code class=\"codespan\">2</code>, ...</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>Each item also includes axis infomation:</p>\n<pre><code class=\"lang-js\">{\n    axisDim: &#39;x&#39;, // &#39;x&#39;, &#39;y&#39;, &#39;angle&#39;, &#39;radius&#39;, &#39;single&#39;\n    axisId: &#39;xxx&#39;,\n    axisName: &#39;xxx&#39;,\n    axisIndex: 3,\n    axisValue: 121, // The current value of axisPointer\n    axisValueLabel: &#39;text of value&#39;\n}\n</code></pre>\n<p><strong>Return:</strong></p>\n<p>The string to be displayed.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">formatter: function (params) {\n    // If axis.type is &#39;time&#39;\n    return &#39;some text&#39; + echarts.format.formatTime(params.value);\n}\n</code></pre>\n","default":null},"margin":{"type":["boolean"],"description":"<p>Distance between label and axis.</p>\n","default":3},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"padding":{"type":["string","Array"],"description":"\n\n<p>axisPointer space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":"[5, 7, 5, 7]"},"backgroundColor":{"type":["string"],"description":"<p>Background color of label, the same as <a href=\"#xAxis.axisLine.lineStyle.color\">axis.axisLine.lineStyle.color</a> by default.</p>\n","default":"'auto'"},"borderColor":{"type":["string"],"description":"<p>Border color of label.</p>\n","default":null},"borderWidth":{"type":["string"],"description":"<p>Border width of label.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"#aaa"},"default":"#aaa"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"lineStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;line&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#555"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"shadowStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;shadow&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'rgba(150,150,150,0.3)"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"crossStyle":{"type":["Object"],"description":"<p>It is valid when <a href=\"#tooltip.axisPointer.type\">axisPointer.type</a> is <code class=\"codespan\">&#39;cross&#39;</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#555"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"dashed"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":200},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"exponentialOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"position":{"type":["string","Array"],"description":"<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n\n\n\n\n\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n\n\n\n\n\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n\n\n\n\n\n\n\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},"timeline":{"type":["Object"],"description":"<p><code class=\"codespan\">timeline</code> component, which provides functions like switching and playing between multiple ECharts <code class=\"codespan\">options</code>.</p>\n<p>Here is an example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/mix-timeline-all&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n<p>Different from other cases, <code class=\"codespan\">timeline</code> component requires multiple options. We call first the parameter of <code class=\"codespan\">setOption</code> as <code class=\"codespan\">ECOption</code>, and call the traditional single ECharts option as <code class=\"codespan\">ECUnitOption</code>.</p>\n<ul>\n<li>In the case that <code class=\"codespan\">timeline</code> and <code class=\"codespan\">media query</code> are not set, an <code class=\"codespan\">ECUnitOption</code> is an <code class=\"codespan\">ECOption</code>.</li>\n<li>In the case that <code class=\"codespan\">timeline</code> or <code class=\"codespan\">media query</code> are set, an <code class=\"codespan\">ECOption</code> is made up with several <code class=\"codespan\">ECUnitOption</code>s.<ul>\n<li>The properties at the root of <code class=\"codespan\">ECOption</code> form an <code class=\"codespan\">ECUnitOption</code>, which is also called <code class=\"codespan\">baseOption</code>, representing the default settings.</li>\n<li>Each item of the array <code class=\"codespan\">options</code> form an <code class=\"codespan\">ECUnitOption</code>, which can be also called <code class=\"codespan\">switchableOption</code>, representing options for each time tick.</li>\n</ul>\n</li>\n<li><code class=\"codespan\">baseOption</code> and one <code class=\"codespan\">switchableOption</code> are used to calculate the <code class=\"codespan\">finalOption</code>, based on which the chart will be final rendered.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">myChart.setOption({\n    // This is the properties of `baseOption`.\n    timeline: {\n        ...,\n        // each item in `timeline.data` corresponds to each\n        // `option` in `options` array.\n        data: [&#39;2002-01-01&#39;, &#39;2003-01-01&#39;, &#39;2004-01-01&#39;]\n    },\n    title: {\n        subtext: &#39; Data is from National Bureau of Statistics &#39;\n    },\n    grid: { ... },\n    xAxis: [ ... ],\n    yAxis: [ ... ],\n    series: [{\n        // other configurations of series 1\n        type: &#39;bar&#39;,\n        ...\n    }, {\n        // other configurations of series 2\n        type: &#39;line&#39;,\n        ...\n    }, {\n        // other configurations of series 3\n        type: &#39;pie&#39;,\n        ...\n    }],\n    // `switchableOption`s:\n    options: [{\n        // it is an option corresponding to &#39;2002-01-01&#39;\n        title: {\n        text: &#39;the statistics of the year 2002&#39;\n        },\n        series: [\n            { data: [] }, // the data of series 1\n            { data: [] }, // the data of series 2\n            { data: [] }  // the data of series 3\n        ]\n    }, {\n        // it is an option corresponding to &#39;2003-01-01&#39;\n        title: {\n            text: &#39;the statistics of the year 2003&#39;\n        },\n        series: [\n            { data: [] },\n            { data: [] },\n            { data: [] }\n        ]\n    }, {\n        // it is an option corresponding to &#39;2004-01-01&#39;\n        title: {\n            text: &#39;the statistics of the year 2004&#39;\n        },\n        series: [\n            { data: [] },\n            { data: [] },\n            { data: [] }\n        ]\n    }]\n});\n</code></pre>\n<p><br>\n<strong>How the <code class=\"codespan\">finalOption</code> calculated?</strong></p>\n<p>When initializing, a <code class=\"codespan\">switchableOption</code> corresponding to the current time tick are merged into <code class=\"codespan\">baseOption</code> to form the <code class=\"codespan\">finalOption</code>. Each time the current tick changed, the new <code class=\"codespan\">switchableOption</code> corresponding to the new time tick are merged into the <code class=\"codespan\">finalOption</code>.</p>\n<p>There are two merging strategy.</p>\n<ul>\n<li>By default, use <code class=\"codespan\">NORMAL_MERGE</code>.</li>\n<li>If <a href=\"#option.html#timeline.replaceMerge\">timeline.replaceMerge</a> is set, use <code class=\"codespan\">REPLACE_MERGE</code>. See <a href=\"#api.html#echartsInstance.setOption\">setOption</a> for more details of <code class=\"codespan\">REPLACE_MERGE</code>.</li>\n</ul>\n<p><br>\n<strong>Compatibility with ECharts 4:</strong></p>\n<p>We also support these equivalent setting styles:</p>\n<pre><code class=\"lang-js\">option = {\n    baseOption: {\n        timeline: {},\n        series: [],\n        // ... other properties of baseOption.\n    },\n    options: []\n};\n</code></pre>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the <code class=\"codespan\">timeline</code> component. It would not show with a setting of <code class=\"codespan\">false</code>, but its functions still remain.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"type":{"type":["string"],"description":"<p>This attribute has only one valid value as <code class=\"codespan\">slider</code> by now. You don&#39;t have to change it.</p>\n","default":"'slider'"},"axisType":{"type":["string"],"description":"<p>Type of axis, whose values may be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;value&#39;</code>\n  Numeric axis, which is suitable for continuous data.</li>\n<li><code class=\"codespan\">&#39;category&#39;</code>\n  Category axis, which is suitable for category data.</li>\n<li><code class=\"codespan\">&#39;time&#39;</code>\n  Time axis, which is suitable for continuous time data. Compared with value axis, time axis is equipped with time formatting function and has a different method when calculating axis ticks. For example, for time axis, axis ticks may vary in choosing unit as month, week, date, or hour based on the range of data.</li>\n</ul>\n","default":"'time'"},"currentIndex":{"type":["number"],"description":"\n\n<p>Indicates which is the currently selected item. For instance, if <code class=\"codespan\">currentIndex</code> is <code class=\"codespan\">0</code>, it indicates that the currently selected item is <code class=\"codespan\">timeline.data[0]</code> (namely, using <code class=\"codespan\">options[0]</code>).</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":0},"autoPlay":{"type":["boolean"],"description":"\n\n<p>Whether to play automatically.</p>\n","uiControl":{"type":"boolean"},"default":false},"rewind":{"type":["boolean"],"description":"\n\n<p>Whether supports playing reversely.</p>\n","uiControl":{"type":"boolean"},"default":false},"loop":{"type":["boolean"],"description":"\n\n<p>Whether to loop playing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"playInterval":{"type":["number"],"description":"\n\n<p>Indicates play speed (gap time between two state), whose unit is millisecond.</p>\n","uiControl":{"type":"number","min":"0","step":"20","default":"2000"},"default":2000},"realtime":{"type":["boolean"],"description":"\n\n<p>Whether the view updates in real time during dragging the control dot.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"replaceMerge":{"type":["Array","string"],"description":"<p>When initializing, a <code class=\"codespan\">switchableOption</code> corresponding to the current time tick are merged into <code class=\"codespan\">baseOption</code> to form the <code class=\"codespan\">finalOption</code>. Each time the current tick changed, the new <code class=\"codespan\">switchableOption</code> corresponding to the new time tick are merged into the <code class=\"codespan\">finalOption</code>.</p>\n<p>There are two merging strategy.</p>\n<ul>\n<li>By default, use <code class=\"codespan\">NORMAL_MERGE</code>.</li>\n<li>If <a href=\"#option.html#timeline.replaceMerge\">timeline.replaceMerge</a> is set, use <code class=\"codespan\">REPLACE_MERGE</code>. See <a href=\"#api.html#echartsInstance.setOption\">setOption</a> for more details of <code class=\"codespan\">REPLACE_MERGE</code>.</li>\n</ul>\n<p><br></p>\n<p>The value of <code class=\"codespan\">replaceMerge</code> can be a <code class=\"codespan\">mainType</code> of a component, like <code class=\"codespan\">replaceMerge: &#39;xAxis&#39;</code>, or an array of <code class=\"codespan\">mainType</code>s, like <code class=\"codespan\">replaceMerge: [&#39;xAxis&#39;, &#39;series&#39;]</code>.</p>\n<p><code class=\"codespan\">replaceMerge</code> is usually used in this scenario: if users intending to replace all of the current series with the new series corresponding to the next time tick without any merging, users can set: <code class=\"codespan\">replaceMerge: &#39;series&#39;</code>, and make sure that the series are in different id or no id.</p>\n<p>See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/timeline-dynamic-series&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>.</p>\n","default":"undefined"},"controlPosition":{"type":["string"],"description":"\n\n<p>Position of the play button, whose valid values are <code class=\"codespan\">&#39;left&#39;</code> and <code class=\"codespan\">&#39;right&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"left,right"},"default":"'left'"},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between timeline component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'auto'"},"top":{"type":["string","number"],"description":"<p>Distance between timeline component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'auto'"},"right":{"type":["string","number"],"description":"<p>Distance between timeline component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"bottom":{"type":["string","number"],"description":"<p>Distance between timeline component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"padding":{"type":["number","Array"],"description":"\n\n\n\n\n\n<p>timeline space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"orient":{"type":["string"],"description":"\n\n<p>Orientation of the component, whose valid values are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;vertical&#39;</code>: vertical layout.</li>\n<li><code class=\"codespan\">&#39;horizontal&#39;</code>: horizontal layout.</li>\n</ul>\n","uiControl":{"type":"enum","options":"horizontal,vertical","default":"horizontal"},"default":"'horizontal'"},"inverse":{"type":["boolean"],"description":"\n\n<ul>\n<li>Whether to put the <code class=\"codespan\">timeline</code> component reversely, which makes the elements in the front to be at the end.</li>\n</ul>\n","uiControl":{"type":"boolean"},"default":false},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of timeline.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"},"default":"'emptyCircle'"},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>timeline symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"},"default":10},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of timeline symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of timeline symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the axis. It can be set to be <code class=\"codespan\">false</code> to hide the axis line to make a different style.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"color":{"type":["Color"],"description":"\n\n<p>timeline Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#DAE1F5'"},"width":{"type":["number"],"description":"\n\n<p>timeline  line width.</p>\n","uiControl":{"type":"number","value":"2","min":"0","step":"0.5"},"default":2},"type":{"type":["string"],"description":"\n\n<p>timeline  line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label axis, <code class=\"codespan\">emphasis</code> is the highlighted style of text. For instance, text style in <code class=\"codespan\">emphasis</code> would be used when mouse hovers or legend connects.</p>\n","properties":{"position":{"type":["string","number"],"description":"\n\n\n\n<p>Configurations:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;auto&#39;</code>:\n  Automatic layout.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code>:\n  Put it along the left margin.\n  It is valid when <a href=\"#timeline.orient\">timline.orient</a> is set as <code class=\"codespan\">&#39;horizontal&#39;</code> .</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code>:\n  Put it along the right margin.\n  It is valid when <a href=\"#timeline.orient\">timline.orient</a> is set as <code class=\"codespan\">&#39;horizontal&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code>:\n  Put it along the margin of the top.\n  It is valid when <a href=\"#timeline.orient\">timline.orient</a> is set as <code class=\"codespan\">&#39;vertical&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code>:\n  Put it along the margin of the bottom.\n  It is valid when <a href=\"#timeline.orient\">timline.orient</a> is set as <code class=\"codespan\">&#39;vertical&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">number</code>:\n  When it is assigned to be a a number value, it indicates the distance between <code class=\"codespan\">label</code> and axis. If it is set to be <code class=\"codespan\">0</code> , <code class=\"codespan\">label</code> would be at the same position with axis. Negative value is valid for the other side of the axis.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"auto,left,right,top,bottom"},"default":"'auto'"},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"interval":{"type":["string","number"],"description":"<p>Interval of <code class=\"codespan\">label</code>. When it is assigned with a numerical value, such as  <code class=\"codespan\">2</code>, a label would show every 2 items.</p>\n","default":"'auto'"},"rotate":{"type":["prefix"],"description":"<p>Rotation angle of <code class=\"codespan\">label</code>, in which positive values refer to counter clockwise rotation.</p>\n","default":0},"formatter":{"type":["string","Function"],"description":"<p>Formatter of axis label, which supports string template and callback function.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use string template; template variable is the default label of axis {value}\nformatter: &#39;{value} kg&#39;\n// Use callback.\nformatter: function (value, index) {\n    return value + &#39;kg&#39;;\n}\n</code></pre>\n<hr>\n<p>For axes of time <a href=\"#.type\">type</a>: <code class=\"codespan\">&#39;time&#39;</code>, <code class=\"codespan\">formatter</code> supports the following forms:</p>\n<ul>\n<li><strong>String Templates</strong>: an easy and fast way to make frequently used date/time template, formed in <code class=\"codespan\">string</code></li>\n<li><strong>Callback Functions</strong>: customized formatter to make complex format, formed in <code class=\"codespan\">Function</code></li>\n<li><strong>Cascading Templates</strong>: to adopt different formatters for different time granularity, formed in <code class=\"codespan\">object</code></li>\n</ul>\n<p>Next, we are going to introduce these three forms one by one.</p>\n<p><strong> String Templates </strong></p>\n<p>Using string templates is an easy way to format date/time with frequently used formats. If it can be used to make what you want, you are advised to do so. If not, you could then consider the others. Supported formats are:</p>\n<table>\n<thead>\n<tr>\n<th>Group</th>\n<th>Template</th>\n<th>Value (EN)</th>\n<th>Value (ZH)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Year</td>\n<td>{yyyy}</td>\n<td>e.g., 2020, 2021, ...</td>\n<td>例：2020, 2021, ...</td>\n</tr>\n<tr>\n<td></td>\n<td>{yy}</td>\n<td>00-99</td>\n<td>00-99</td>\n</tr>\n<tr>\n<td>Quarter</td>\n<td>{Q}</td>\n<td>1, 2, 3, 4</td>\n<td>1, 2, 3, 4</td>\n</tr>\n<tr>\n<td>Month</td>\n<td>{MMMM}</td>\n<td>e.g., January, February, ...</td>\n<td>一月、二月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MMM}</td>\n<td>e.g., Jan, Feb, ...</td>\n<td>1月、2月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MM}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{M}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Day of Month</td>\n<td>{dd}</td>\n<td>01-31</td>\n<td>01-31</td>\n</tr>\n<tr>\n<td></td>\n<td>{d}</td>\n<td>1-31</td>\n<td>1-31</td>\n</tr>\n<tr>\n<td>Day of Week</td>\n<td>{eeee}</td>\n<td>Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday</td>\n<td>星期日、星期一、星期二、星期三、星期四、星期五、星期六</td>\n</tr>\n<tr>\n<td></td>\n<td>{ee}</td>\n<td>Sun, Mon, Tues, Wed, Thu, Fri, Sat</td>\n<td>日、一、二、三、四、五、六</td>\n</tr>\n<tr>\n<td></td>\n<td>{e}</td>\n<td>1-54</td>\n<td>1-54</td>\n</tr>\n<tr>\n<td>Hour</td>\n<td>{HH}</td>\n<td>00-23</td>\n<td>00-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{H}</td>\n<td>0-23</td>\n<td>0-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{hh}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{h}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Minute</td>\n<td>{mm}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{m}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Second</td>\n<td>{ss}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{s}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Millisecond</td>\n<td>{SSS}</td>\n<td>000-999</td>\n<td>000-999</td>\n</tr>\n<tr>\n<td></td>\n<td>{S}</td>\n<td>0-999</td>\n<td>0-999</td>\n</tr>\n</tbody>\n</table>\n<blockquote>\n<p>Templates of other languages can be found in <a href=\"https://github.com/apache/echarts/tree/master/src/i18n\" target=\"_blank\">the language package</a>. Please refer to <a href=\"api.html#echarts.registerLocale\" target=\"_blank\">echarts.registerLocale</a> to register a language.</p>\n</blockquote>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: &#39;{yyyy}-{MM}-{dd}&#39; // gets labels like &#39;2020-12-02&#39;\nformatter: &#39;Day {d}&#39; // gets labels like &#39;Day 2&#39;\n</code></pre>\n<p><strong> Callback Functions </strong></p>\n<p>Callback functions can be used to get different formats for different axis tick values. Sometimes, if you have complex date/time formatting requirement, third-party libraries like <a href=\"https://momentjs.com/\" target=\"_blank\">Moment.js</a> or <a href=\"https://date-fns.org/\" target=\"_blank\">date-fns</a> can be used to return formatted labels.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use callback function; function parameters are axis index\nformatter: function (value, index) {\n    // Formatted to be month/day; display year only in the first label\n    var date = new Date(value);\n    var texts = [(date.getMonth() + 1), date.getDate()];\n    if (idx === 0) {\n        texts.unshift(date.getYear());\n    }\n    return texts.join(&#39;/&#39;);\n}\n</code></pre>\n<p><strong> Cascading Templates </strong></p>\n<p>Sometimes, we wish to use different formats for different time granularity. For example, in a quarter-year chart, we may wish to see the month name with the first date of the month, while see the date name with others. This can be made with:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: {\n    month: &#39;{MMMM}&#39;, // Jan, Feb, ...\n    day: &#39;{d}&#39; // 1, 2, ...\n}\n</code></pre>\n<p>Supported levels and their default formatters are:</p>\n<pre><code class=\"lang-js\">{\n    year: &#39;{yyyy}&#39;,\n    month: &#39;{MMM}&#39;,\n    day: &#39;{d}&#39;,\n    hour: &#39;{HH}:{mm}&#39;,\n    minute: &#39;{HH}:{mm}&#39;,\n    second: &#39;{HH}:{mm}:{ss}&#39;,\n    millisecond: &#39;{hh}:{mm}:{ss} {SSS}&#39;,\n    none: &#39;{yyyy}-{MM}-{dd} {hh}:{mm}:{ss} {SSS}&#39;\n}\n</code></pre>\n<p>Let&#39;s take <code class=\"codespan\">day</code> for example. When a tick value is <code class=\"codespan\">0</code> for its hour, minute, second, and millisecond, <code class=\"codespan\">day</code> level will be used to make formatter. <code class=\"codespan\">none</code> is used when no other level fulfills, which is for tick values with millisecond values other than <code class=\"codespan\">0</code>.</p>\n<p><strong> Rich Text </strong></p>\n<p>The above three forms all support rich text, so it can be used to make some complex effects.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: {\n            // Display year and month information on the first data of a year\n            year: &#39;{yearStyle|{yyyy}}\\n{monthStyle|{MMM}}&#39;,\n            month: &#39;{monthStyle|{MMM}}&#39;\n        },\n        rich: {\n            yearStyle: {\n                // Make yearly text more standing out\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            monthStyle: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n<p>The above example can also be made with a callback function:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: function (value) {\n            const date = new Date(value);\n            const yearStart = new Date(value);\n            yearStart.setMonth(0);\n            yearStart.setDate(1);\n            yearStart.setHours(0);\n            yearStart.setMinutes(0);\n            yearStart.setSeconds(0);\n            yearStart.setMilliseconds(0);\n            // Whether a tick value is the start of a year\n            if (date.getTime() === yearStart.getTime()) {\n                return &#39;{year|&#39; + date.getFullYear() + &#39;}\\n&#39;\n                    + &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;;\n            }\n            else {\n                return &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;\n            }\n        },\n        rich: {\n            year: {\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            month: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n","default":null},"color":{"type":["Color"],"description":"\n\n<p>timeline.lable text color.</p>\n","uiControl":{"type":"color","default":"'#A4B1D7'"},"default":"'#A4B1D7'"},"fontStyle":{"type":["string"],"description":"\n\n<p>timeline.lable font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p>timeline.lable font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p>timeline.lable font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p>timeline.lable font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of timeline , <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>timeline  color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#A4B1D7'"},"borderColor":{"type":["Color"],"description":"\n\n<p>timeline  border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>timeline  border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"checkpointStyle":{"type":["Object"],"description":"<p>Style of the selected item (<code class=\"codespan\">checkpoint</code>).</p>\n","properties":{"symbol":{"type":["string"],"description":"\n\n<p>Symbol of timeline.checkpointStyle .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"},"default":"'circle'"},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>timeline.checkpointStyle  symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"},"default":13},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of timeline.checkpointStyle  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of timeline.checkpointStyle  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#316bf3'"},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#fff'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"2","min":"0","step":"0.5"},"default":2},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"2","min":"0","step":"0.5"},"default":2},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"&#39;rgba(0, 0, 0, 0.3)&#39;"},"default":"'rgba(0, 0, 0, 0.3)'"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"1","step":"0.5"},"default":1},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"1","step":"0.5"},"default":1},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"animation":{"type":["boolean"],"description":"\n\n<p>In <code class=\"codespan\">timeline</code> component, whether there is animation in <code class=\"codespan\">checkpoint</code> moving during the process of <code class=\"codespan\">timeline</code> playing and switching.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"animationDuration":{"type":["number"],"description":"\n\n<p>The animation duration of <code class=\"codespan\">checkpoint</code> in <code class=\"codespan\">timeline</code> component.</p>\n","uiControl":{"type":"number","min":"0","step":"20","default":"300"},"default":300},"animationEasing":{"type":["string"],"description":"\n\n<p>The easing effect of animation of <code class=\"codespan\">checkpoint</code> in <code class=\"codespan\">timeline</code> component. Refers to <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=line-easing\" target=\"_blank\">easing sample</a> for different easing effects.</p>\n","uiControl":{"type":"enum","default":"quinticInOut","options":"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"},"default":"'quinticInOut'"}}},"controlStyle":{"type":["Object"],"description":"<p>The style of <em>control button</em>, which includes: <em>play button</em>, <em>previous button</em>, and <em>next button</em>.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show control button. <code class=\"codespan\">false</code> for hide all.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"showPlayBtn":{"type":["boolean"],"description":"\n\n<p>Whether to show play button.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"showPrevBtn":{"type":["boolean"],"description":"\n\n<p>Whether to show previous button.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"showNextBtn":{"type":["boolean"],"description":"\n\n<p>Whether to show next button.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"itemSize":{"type":["number"],"description":"\n\n<p>Size of <em>control button</em>, in pixels (px).</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"22"},"default":22},"itemGap":{"type":["number"],"description":"\n\n<p>Interval between <em>control button</em>, in pixels (px).</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"12"},"default":12},"position":{"type":["string"],"description":"\n\n<p>the location of <em>control button</em>.</p>\n<ul>\n<li><p>When <a href=\"#timeline.orient\">timeline.orient</a> is set to be <code class=\"codespan\">&#39;horizontal&#39;</code>, <code class=\"codespan\">&#39;left&#39;</code> and <code class=\"codespan\">&#39;right&#39;</code>are valid.</p>\n</li>\n<li><p>When <a href=\"#timeline.orient\">timeline.orient</a> is set to be <code class=\"codespan\">&#39;vertical&#39;</code>, <code class=\"codespan\">&#39;top&#39;</code> and <code class=\"codespan\">&#39;bottom&#39;</code>are valid.</p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"left,right,top,bottom"},"default":"'left'"},"playIcon":{"type":["string"],"description":"\n\n<p>Icon of <em>play status</em> for <em>play button</em>.</p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon"}},"stopIcon":{"type":["string"],"description":"\n\n<p>Icon of <em>stop status</em> for <em>play button</em>.</p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon"}},"prevIcon":{"type":["string"],"description":"\n\n<p>Icon of <em>previous button</em>.</p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon"}},"nextIcon":{"type":["string"],"description":"\n\n<p>Icon of <em>next button</em>.</p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon"}},"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#A4B1D7'"},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#A4B1D7'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"progress":{"type":["Object"],"description":"<p>Styles of line, labels and symbols in progress.</p>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#316BF3'"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#316BF3'"},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"interval":{"type":["string","number"],"description":"<p>Interval of <code class=\"codespan\">label</code>. When it is assigned with a numerical value, such as  <code class=\"codespan\">2</code>, a label would show every 2 items.</p>\n","default":"'auto'"},"rotate":{"type":["prefix"],"description":"<p>Rotation angle of <code class=\"codespan\">label</code>, in which positive values refer to counter clockwise rotation.</p>\n","default":0},"formatter":{"type":["string","Function"],"description":"<p>Formatter of axis label, which supports string template and callback function.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use string template; template variable is the default label of axis {value}\nformatter: &#39;{value} kg&#39;\n// Use callback.\nformatter: function (value, index) {\n    return value + &#39;kg&#39;;\n}\n</code></pre>\n<hr>\n<p>For axes of time <a href=\"#.type\">type</a>: <code class=\"codespan\">&#39;time&#39;</code>, <code class=\"codespan\">formatter</code> supports the following forms:</p>\n<ul>\n<li><strong>String Templates</strong>: an easy and fast way to make frequently used date/time template, formed in <code class=\"codespan\">string</code></li>\n<li><strong>Callback Functions</strong>: customized formatter to make complex format, formed in <code class=\"codespan\">Function</code></li>\n<li><strong>Cascading Templates</strong>: to adopt different formatters for different time granularity, formed in <code class=\"codespan\">object</code></li>\n</ul>\n<p>Next, we are going to introduce these three forms one by one.</p>\n<p><strong> String Templates </strong></p>\n<p>Using string templates is an easy way to format date/time with frequently used formats. If it can be used to make what you want, you are advised to do so. If not, you could then consider the others. Supported formats are:</p>\n<table>\n<thead>\n<tr>\n<th>Group</th>\n<th>Template</th>\n<th>Value (EN)</th>\n<th>Value (ZH)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Year</td>\n<td>{yyyy}</td>\n<td>e.g., 2020, 2021, ...</td>\n<td>例：2020, 2021, ...</td>\n</tr>\n<tr>\n<td></td>\n<td>{yy}</td>\n<td>00-99</td>\n<td>00-99</td>\n</tr>\n<tr>\n<td>Quarter</td>\n<td>{Q}</td>\n<td>1, 2, 3, 4</td>\n<td>1, 2, 3, 4</td>\n</tr>\n<tr>\n<td>Month</td>\n<td>{MMMM}</td>\n<td>e.g., January, February, ...</td>\n<td>一月、二月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MMM}</td>\n<td>e.g., Jan, Feb, ...</td>\n<td>1月、2月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MM}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{M}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Day of Month</td>\n<td>{dd}</td>\n<td>01-31</td>\n<td>01-31</td>\n</tr>\n<tr>\n<td></td>\n<td>{d}</td>\n<td>1-31</td>\n<td>1-31</td>\n</tr>\n<tr>\n<td>Day of Week</td>\n<td>{eeee}</td>\n<td>Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday</td>\n<td>星期日、星期一、星期二、星期三、星期四、星期五、星期六</td>\n</tr>\n<tr>\n<td></td>\n<td>{ee}</td>\n<td>Sun, Mon, Tues, Wed, Thu, Fri, Sat</td>\n<td>日、一、二、三、四、五、六</td>\n</tr>\n<tr>\n<td></td>\n<td>{e}</td>\n<td>1-54</td>\n<td>1-54</td>\n</tr>\n<tr>\n<td>Hour</td>\n<td>{HH}</td>\n<td>00-23</td>\n<td>00-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{H}</td>\n<td>0-23</td>\n<td>0-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{hh}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{h}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Minute</td>\n<td>{mm}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{m}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Second</td>\n<td>{ss}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{s}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Millisecond</td>\n<td>{SSS}</td>\n<td>000-999</td>\n<td>000-999</td>\n</tr>\n<tr>\n<td></td>\n<td>{S}</td>\n<td>0-999</td>\n<td>0-999</td>\n</tr>\n</tbody>\n</table>\n<blockquote>\n<p>Templates of other languages can be found in <a href=\"https://github.com/apache/echarts/tree/master/src/i18n\" target=\"_blank\">the language package</a>. Please refer to <a href=\"api.html#echarts.registerLocale\" target=\"_blank\">echarts.registerLocale</a> to register a language.</p>\n</blockquote>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: &#39;{yyyy}-{MM}-{dd}&#39; // gets labels like &#39;2020-12-02&#39;\nformatter: &#39;Day {d}&#39; // gets labels like &#39;Day 2&#39;\n</code></pre>\n<p><strong> Callback Functions </strong></p>\n<p>Callback functions can be used to get different formats for different axis tick values. Sometimes, if you have complex date/time formatting requirement, third-party libraries like <a href=\"https://momentjs.com/\" target=\"_blank\">Moment.js</a> or <a href=\"https://date-fns.org/\" target=\"_blank\">date-fns</a> can be used to return formatted labels.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use callback function; function parameters are axis index\nformatter: function (value, index) {\n    // Formatted to be month/day; display year only in the first label\n    var date = new Date(value);\n    var texts = [(date.getMonth() + 1), date.getDate()];\n    if (idx === 0) {\n        texts.unshift(date.getYear());\n    }\n    return texts.join(&#39;/&#39;);\n}\n</code></pre>\n<p><strong> Cascading Templates </strong></p>\n<p>Sometimes, we wish to use different formats for different time granularity. For example, in a quarter-year chart, we may wish to see the month name with the first date of the month, while see the date name with others. This can be made with:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: {\n    month: &#39;{MMMM}&#39;, // Jan, Feb, ...\n    day: &#39;{d}&#39; // 1, 2, ...\n}\n</code></pre>\n<p>Supported levels and their default formatters are:</p>\n<pre><code class=\"lang-js\">{\n    year: &#39;{yyyy}&#39;,\n    month: &#39;{MMM}&#39;,\n    day: &#39;{d}&#39;,\n    hour: &#39;{HH}:{mm}&#39;,\n    minute: &#39;{HH}:{mm}&#39;,\n    second: &#39;{HH}:{mm}:{ss}&#39;,\n    millisecond: &#39;{hh}:{mm}:{ss} {SSS}&#39;,\n    none: &#39;{yyyy}-{MM}-{dd} {hh}:{mm}:{ss} {SSS}&#39;\n}\n</code></pre>\n<p>Let&#39;s take <code class=\"codespan\">day</code> for example. When a tick value is <code class=\"codespan\">0</code> for its hour, minute, second, and millisecond, <code class=\"codespan\">day</code> level will be used to make formatter. <code class=\"codespan\">none</code> is used when no other level fulfills, which is for tick values with millisecond values other than <code class=\"codespan\">0</code>.</p>\n<p><strong> Rich Text </strong></p>\n<p>The above three forms all support rich text, so it can be used to make some complex effects.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: {\n            // Display year and month information on the first data of a year\n            year: &#39;{yearStyle|{yyyy}}\\n{monthStyle|{MMM}}&#39;,\n            month: &#39;{monthStyle|{MMM}}&#39;\n        },\n        rich: {\n            yearStyle: {\n                // Make yearly text more standing out\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            monthStyle: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n<p>The above example can also be made with a callback function:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: function (value) {\n            const date = new Date(value);\n            const yearStart = new Date(value);\n            yearStart.setMonth(0);\n            yearStart.setDate(1);\n            yearStart.setHours(0);\n            yearStart.setMinutes(0);\n            yearStart.setSeconds(0);\n            yearStart.setMilliseconds(0);\n            // Whether a tick value is the start of a year\n            if (date.getTime() === yearStart.getTime()) {\n                return &#39;{year|&#39; + date.getFullYear() + &#39;}\\n&#39;\n                    + &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;;\n            }\n            else {\n                return &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;\n            }\n        },\n        rich: {\n            year: {\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            month: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n","default":null},"color":{"type":["Color"],"description":"\n\n<p>timeline.lable text color.</p>\n","uiControl":{"type":"color","default":"'#6f778d'"},"default":"'#6f778d'"},"fontStyle":{"type":["string"],"description":"\n\n<p>timeline.lable font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p>timeline.lable font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p>timeline.lable font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p>timeline.lable font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"interval":{"type":["string","number"],"description":"<p>Interval of <code class=\"codespan\">label</code>. When it is assigned with a numerical value, such as  <code class=\"codespan\">2</code>, a label would show every 2 items.</p>\n","default":"'auto'"},"rotate":{"type":["prefix"],"description":"<p>Rotation angle of <code class=\"codespan\">label</code>, in which positive values refer to counter clockwise rotation.</p>\n","default":0},"formatter":{"type":["string","Function"],"description":"<p>Formatter of axis label, which supports string template and callback function.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use string template; template variable is the default label of axis {value}\nformatter: &#39;{value} kg&#39;\n// Use callback.\nformatter: function (value, index) {\n    return value + &#39;kg&#39;;\n}\n</code></pre>\n<hr>\n<p>For axes of time <a href=\"#.type\">type</a>: <code class=\"codespan\">&#39;time&#39;</code>, <code class=\"codespan\">formatter</code> supports the following forms:</p>\n<ul>\n<li><strong>String Templates</strong>: an easy and fast way to make frequently used date/time template, formed in <code class=\"codespan\">string</code></li>\n<li><strong>Callback Functions</strong>: customized formatter to make complex format, formed in <code class=\"codespan\">Function</code></li>\n<li><strong>Cascading Templates</strong>: to adopt different formatters for different time granularity, formed in <code class=\"codespan\">object</code></li>\n</ul>\n<p>Next, we are going to introduce these three forms one by one.</p>\n<p><strong> String Templates </strong></p>\n<p>Using string templates is an easy way to format date/time with frequently used formats. If it can be used to make what you want, you are advised to do so. If not, you could then consider the others. Supported formats are:</p>\n<table>\n<thead>\n<tr>\n<th>Group</th>\n<th>Template</th>\n<th>Value (EN)</th>\n<th>Value (ZH)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Year</td>\n<td>{yyyy}</td>\n<td>e.g., 2020, 2021, ...</td>\n<td>例：2020, 2021, ...</td>\n</tr>\n<tr>\n<td></td>\n<td>{yy}</td>\n<td>00-99</td>\n<td>00-99</td>\n</tr>\n<tr>\n<td>Quarter</td>\n<td>{Q}</td>\n<td>1, 2, 3, 4</td>\n<td>1, 2, 3, 4</td>\n</tr>\n<tr>\n<td>Month</td>\n<td>{MMMM}</td>\n<td>e.g., January, February, ...</td>\n<td>一月、二月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MMM}</td>\n<td>e.g., Jan, Feb, ...</td>\n<td>1月、2月、……</td>\n</tr>\n<tr>\n<td></td>\n<td>{MM}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{M}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Day of Month</td>\n<td>{dd}</td>\n<td>01-31</td>\n<td>01-31</td>\n</tr>\n<tr>\n<td></td>\n<td>{d}</td>\n<td>1-31</td>\n<td>1-31</td>\n</tr>\n<tr>\n<td>Day of Week</td>\n<td>{eeee}</td>\n<td>Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday</td>\n<td>星期日、星期一、星期二、星期三、星期四、星期五、星期六</td>\n</tr>\n<tr>\n<td></td>\n<td>{ee}</td>\n<td>Sun, Mon, Tues, Wed, Thu, Fri, Sat</td>\n<td>日、一、二、三、四、五、六</td>\n</tr>\n<tr>\n<td></td>\n<td>{e}</td>\n<td>1-54</td>\n<td>1-54</td>\n</tr>\n<tr>\n<td>Hour</td>\n<td>{HH}</td>\n<td>00-23</td>\n<td>00-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{H}</td>\n<td>0-23</td>\n<td>0-23</td>\n</tr>\n<tr>\n<td></td>\n<td>{hh}</td>\n<td>01-12</td>\n<td>01-12</td>\n</tr>\n<tr>\n<td></td>\n<td>{h}</td>\n<td>1-12</td>\n<td>1-12</td>\n</tr>\n<tr>\n<td>Minute</td>\n<td>{mm}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{m}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Second</td>\n<td>{ss}</td>\n<td>00-59</td>\n<td>00-59</td>\n</tr>\n<tr>\n<td></td>\n<td>{s}</td>\n<td>0-59</td>\n<td>0-59</td>\n</tr>\n<tr>\n<td>Millisecond</td>\n<td>{SSS}</td>\n<td>000-999</td>\n<td>000-999</td>\n</tr>\n<tr>\n<td></td>\n<td>{S}</td>\n<td>0-999</td>\n<td>0-999</td>\n</tr>\n</tbody>\n</table>\n<blockquote>\n<p>Templates of other languages can be found in <a href=\"https://github.com/apache/echarts/tree/master/src/i18n\" target=\"_blank\">the language package</a>. Please refer to <a href=\"api.html#echarts.registerLocale\" target=\"_blank\">echarts.registerLocale</a> to register a language.</p>\n</blockquote>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: &#39;{yyyy}-{MM}-{dd}&#39; // gets labels like &#39;2020-12-02&#39;\nformatter: &#39;Day {d}&#39; // gets labels like &#39;Day 2&#39;\n</code></pre>\n<p><strong> Callback Functions </strong></p>\n<p>Callback functions can be used to get different formats for different axis tick values. Sometimes, if you have complex date/time formatting requirement, third-party libraries like <a href=\"https://momentjs.com/\" target=\"_blank\">Moment.js</a> or <a href=\"https://date-fns.org/\" target=\"_blank\">date-fns</a> can be used to return formatted labels.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">// Use callback function; function parameters are axis index\nformatter: function (value, index) {\n    // Formatted to be month/day; display year only in the first label\n    var date = new Date(value);\n    var texts = [(date.getMonth() + 1), date.getDate()];\n    if (idx === 0) {\n        texts.unshift(date.getYear());\n    }\n    return texts.join(&#39;/&#39;);\n}\n</code></pre>\n<p><strong> Cascading Templates </strong></p>\n<p>Sometimes, we wish to use different formats for different time granularity. For example, in a quarter-year chart, we may wish to see the month name with the first date of the month, while see the date name with others. This can be made with:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: {\n    month: &#39;{MMMM}&#39;, // Jan, Feb, ...\n    day: &#39;{d}&#39; // 1, 2, ...\n}\n</code></pre>\n<p>Supported levels and their default formatters are:</p>\n<pre><code class=\"lang-js\">{\n    year: &#39;{yyyy}&#39;,\n    month: &#39;{MMM}&#39;,\n    day: &#39;{d}&#39;,\n    hour: &#39;{HH}:{mm}&#39;,\n    minute: &#39;{HH}:{mm}&#39;,\n    second: &#39;{HH}:{mm}:{ss}&#39;,\n    millisecond: &#39;{hh}:{mm}:{ss} {SSS}&#39;,\n    none: &#39;{yyyy}-{MM}-{dd} {hh}:{mm}:{ss} {SSS}&#39;\n}\n</code></pre>\n<p>Let&#39;s take <code class=\"codespan\">day</code> for example. When a tick value is <code class=\"codespan\">0</code> for its hour, minute, second, and millisecond, <code class=\"codespan\">day</code> level will be used to make formatter. <code class=\"codespan\">none</code> is used when no other level fulfills, which is for tick values with millisecond values other than <code class=\"codespan\">0</code>.</p>\n<p><strong> Rich Text </strong></p>\n<p>The above three forms all support rich text, so it can be used to make some complex effects.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: {\n            // Display year and month information on the first data of a year\n            year: &#39;{yearStyle|{yyyy}}\\n{monthStyle|{MMM}}&#39;,\n            month: &#39;{monthStyle|{MMM}}&#39;\n        },\n        rich: {\n            yearStyle: {\n                // Make yearly text more standing out\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            monthStyle: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n<p>The above example can also be made with a callback function:</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    type: &#39;time&#39;,\n    axisLabel: {\n        formatter: function (value) {\n            const date = new Date(value);\n            const yearStart = new Date(value);\n            yearStart.setMonth(0);\n            yearStart.setDate(1);\n            yearStart.setHours(0);\n            yearStart.setMinutes(0);\n            yearStart.setSeconds(0);\n            yearStart.setMilliseconds(0);\n            // Whether a tick value is the start of a year\n            if (date.getTime() === yearStart.getTime()) {\n                return &#39;{year|&#39; + date.getFullYear() + &#39;}\\n&#39;\n                    + &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;;\n            }\n            else {\n                return &#39;{month|&#39; + (date.getMonth() + 1) + &#39;月}&#39;\n            }\n        },\n        rich: {\n            year: {\n                color: &#39;#000&#39;,\n                fontWeight: &#39;bold&#39;\n            },\n            month: {\n                color: &#39;#999&#39;\n            }\n        }\n    }\n},\n</code></pre>\n","default":null},"color":{"type":["Color"],"description":"\n\n<p>timeline.lable.emphasis text color.</p>\n","uiControl":{"type":"color","default":"'#6f778d'"},"default":"'#6f778d'"},"fontStyle":{"type":["string"],"description":"\n\n<p>timeline.lable.emphasis font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p>timeline.lable.emphasis font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p>timeline.lable.emphasis font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p>timeline.lable.emphasis font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>timeline  color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#316BF3'"},"borderColor":{"type":["Color"],"description":"\n\n<p>timeline  border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>timeline  border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"checkpointStyle":{"type":["Object"],"description":"<p>Style of the checkpoint.</p>\n"},"controlStyle":{"type":["Object"],"description":"<p>Style of the control button.</p>\n"}}},"data":{"type":["Array"],"description":"<p><code class=\"codespan\">timeline</code> data. Each item of <code class=\"codespan\">Array</code> can be a instant value. If you need to set style individually for a data item, the <code class=\"codespan\">data</code> item should be written as <code class=\"codespan\">Object</code>. In then <code class=\"codespan\">Object</code>, the attribute of <code class=\"codespan\">value</code> is numerical value. Other attributes, such as shown the examples below, could cover the attribute configurations in <code class=\"codespan\">timeline</code>.</p>\n<p>as follows:</p>\n<pre><code class=\"lang-javascript\">[\n    &#39;2002-01-01&#39;,\n    &#39;2003-01-01&#39;,\n    &#39;2004-01-01&#39;,\n    {\n        value: &#39;2005-01-01&#39;,\n        tooltip: {          // enables `tooltip` to be displayed as mouse hovering to this item.\n            formatter: &#39;{b} xxxx&#39;\n        },\n        symbol: &#39;diamond&#39;,  // the special setting of this item&#39;s symbol.\n        symbolSize: 16      // the special setting of this item&#39;s size.\n    },\n    &#39;2006-01-01&#39;,\n    &#39;2007-01-01&#39;,\n    &#39;2008-01-01&#39;,\n    &#39;2009-01-01&#39;,\n    &#39;2010-01-01&#39;,\n    {\n        value: &#39;2011-01-01&#39;,\n        tooltip: {          // enables `tooltip` to be displayed as mouse hovering to this item.\n            formatter: function (params) {\n                return params.name + &#39;xxxx&#39;;\n            }\n        },\n        symbol: &#39;diamond&#39;,\n        symbolSize: 18\n    },\n]\n</code></pre>\n"}}},"graphic":{"type":["*"],"description":"<p><code class=\"codespan\">graphic</code> component enables creating graphic elements in ECharts.</p>\n<p>Those graphic type are supported.</p>\n<p><a href=\"#graphic.elements-image\">image</a>,\n<a href=\"#graphic.elements-text\">text</a>,\n<a href=\"#graphic.elements-circle\">circle</a>,\n<a href=\"#graphic.elements-sector\">sector</a>,\n<a href=\"#graphic.elements-ring\">ring</a>,\n<a href=\"#graphic.elements-polygon\">polygon</a>,\n<a href=\"#graphic.elements-polyline\">polyline</a>,\n<a href=\"#graphic.elements-rect\">rect</a>,\n<a href=\"#graphic.elements-line\">line</a>,\n<a href=\"#graphic.elements-bezierCurve\">bezierCurve</a>,\n<a href=\"#graphic.elements-arc\">arc</a>,\n<a href=\"#graphic.elements-group\">group</a>,</p>\n<p>This example shows how to make a watermark and text block:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-graphic&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n<p>This example use hidden graphic elements to implement dragging:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-draggable&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n\n\n<p><br></p>\n<hr>\n<p><strong>Graphic Component Configuration</strong></p>\n<p>A simple way to define a graphic element:</p>\n<pre><code class=\"lang-javascript\">myChart.setOption({\n    ...,\n    graphic: {\n        type: &#39;image&#39;,\n        ...\n    }\n});\n</code></pre>\n<p>Define multiple graphic elements:</p>\n<pre><code class=\"lang-javascript\">myChart.setOption({\n    ...,\n    graphic: [\n        { // A &#39;image&#39; element.\n            type: &#39;image&#39;,\n            ...\n        },\n        { // A &#39;text&#39; element, with id specified.\n            type: &#39;text&#39;,\n            id: &#39;text1&#39;,\n            ...\n        },\n        { // A &#39;group&#39; element, in which children can be defined.\n            type: &#39;group&#39;,\n            children: [\n                {\n                    type: &#39;rect&#39;,\n                    id: &#39;rect1&#39;,\n                    ...\n                },\n                {\n                    type: &#39;image&#39;,\n                    ...\n                },\n                ...\n            ]\n        }\n        ...\n    ]\n});\n\n</code></pre>\n<p>How to remove or replace existing elements by <code class=\"codespan\">setOption</code>:</p>\n<pre><code class=\"lang-javascript\">myChart.setOption({\n    ...,\n    graphic: [\n        { // Remove the element &#39;text1&#39; defined above.\n            id: &#39;text1&#39;,\n            $action: &#39;remove&#39;,\n            ...\n        },\n        { // Replace the element &#39;rect1&#39; to a new circle element.\n          // Note, although in the sample above &#39;rect1&#39; is a children of a group,\n          // it is not necessary to consider level relationship when setOption\n          // again if you use id to specify them.\n            id: &#39;rect1&#39;,\n            $action: &#39;replace&#39;,\n            type: &#39;circle&#39;,\n            ...\n        }\n    ]\n});\n</code></pre>\n<p>Notice, when using <code class=\"codespan\">setOption</code> to modify existing elements, if id is not specified, new options will be mapped to existing elements by their order, which might bring unexpected result sometimes. So, generally, using id is recommended.</p>\n<p><br></p>\n<hr>\n<p><strong>Graphic Element Configuration</strong></p>\n<p>Different types of graphic elements has their own configuration respectively, but they have these common configuration below:</p>\n<pre><code class=\"lang-javascript\">{\n    // id is used to specifying element when willing to update it.\n    // id can be ignored if you do not need it.\n    id: &#39;xxx&#39;,\n\n    // Specify element type. Can not be ignored when define a element at the first time.\n    type: &#39;image&#39;,\n\n    // All of the properties below can be ignored and a default value will be assigned.\n\n    // Specify the operation should be performed to the element when calling `setOption`.\n    // Default value is &#39;merge&#39;, other values can be &#39;replace&#39; or &#39;remove&#39;.\n    $action: &#39;replace&#39;,\n\n    // These four properties is used to locating the element. Each property can be absolute\n    // value (like 10, means 10 pixel) or precent (like &#39;12%&#39;) or &#39;center&#39;/&#39;middle&#39;.\n    left: 10,\n    // right: 10,\n    top: &#39;center&#39;,\n    // bottom: &#39;10%&#39;,\n\n    shape: {\n        // Here are configurations for shape, like `x`, `y`, `cx`, `cy`, `width`,\n        // `height`, `r`, `points`, ...\n        // Note, if `left`/`right`/`top`/`bottom` has been set, `x`/`y`/`cx`/`cy`\n        // do not work here.\n    },\n\n    style: {\n        // Here are configurations for style of the element, like `fill`, `stroke`,\n        // `lineWidth`, `shadowBlur`, ...\n    },\n\n    // z value of the elements.\n    z: 10,\n    // Whether response to mouse events / touch events.\n    silent: true,\n    // Whether the element is visible.\n    invisible: false,\n    // Used to specify whether the entire transformed element (containing children if is group)\n    // is confined in its container. Optional values: &#39;raw&#39;, &#39;all&#39;.\n    bounding: &#39;raw&#39;,\n    // Can be dragged or not.\n    draggable: false,\n    // Event handler, can also be onmousemove, ondrag, ... (listed below)\n    onclick: function () {...}\n}\n</code></pre>\n<p><br></p>\n<hr>\n<p><strong>Event Handlers of Graphic Element</strong></p>\n<p>These events are supported:\n<code class=\"codespan\">onclick</code>, <code class=\"codespan\">onmouseover</code>, <code class=\"codespan\">onmouseout</code>, <code class=\"codespan\">onmousemove</code>, <code class=\"codespan\">onmousewheel</code>, <code class=\"codespan\">onmousedown</code>, <code class=\"codespan\">onmouseup</code>, <code class=\"codespan\">ondrag</code>, <code class=\"codespan\">ondragstart</code>, <code class=\"codespan\">ondragend</code>, <code class=\"codespan\">ondragenter</code>, <code class=\"codespan\">ondragleave</code>, <code class=\"codespan\">ondragover</code>, <code class=\"codespan\">ondrop</code>.</p>\n<p><br></p>\n<hr>\n<p><strong>Hierarchy of Graphic Elements</strong></p>\n<p>Only <code class=\"codespan\">group</code> element has children, which enable a group of elements to be positioned and transformed together.</p>\n<p><br></p>\n<hr>\n<p><strong>Shape Configuration of Graphic Element</strong></p>\n<p>Elements with different types have different shape setting repectively. For example:</p>\n<pre><code class=\"lang-javascript\">{\n    type: &#39;rect&#39;,\n    shape: {\n        x: 10,\n        y: 10,\n        width: 100,\n        height: 200\n    }\n},\n{\n    type: &#39;circle&#39;,\n    shape: {\n        cx: 20,\n        cy: 30,\n        r: 100\n    }\n},\n{\n    type: &#39;image&#39;,\n    style: {\n        image: &#39;http://xxx.xxx.xxx/a.png&#39;,\n        x: 100,\n        y: 200,\n        width: 230,\n        height: 400\n    }\n},\n{\n    type: &#39;text&#39;,\n    style: {\n        text: &#39;This text&#39;,\n        x: 100,\n        y: 200\n    }\n\n}\n</code></pre>\n<p><br></p>\n<hr>\n<p><strong>Transforming and Absolutely Positioning of Graphic Element</strong></p>\n<p>Element can be transformed (translation, rotation, scale). See <a href=\"#graphic.elements.position\">position</a>, <a href=\"#graphic.elements.rotation\">rotation</a>, <a href=\"#graphic.elements.scale\">scale</a>, <a href=\"#graphic.elements.origin\">origin</a></p>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    type: &#39;rect&#39;, // or any other types.\n\n    // Translation, using [0, 0] by default.\n    position: [100, 200],\n\n    // Scale, using [1, 1] by default.\n    scale: [2, 4],\n\n    // Rotation, using 0 by default. Negative value means rotating clockwise.\n    rotation: Math.PI / 4,\n\n    // Origin point of rotation and scale, using [0, 0] by default.\n    origin: [10, 20],\n\n    shape: {\n        // ...\n    }\n}\n</code></pre>\n<ul>\n<li><p>Each element is transformed in the coordinate system of its parent, namely, transform of a element and its parent can be &quot;stacked&quot;.</p>\n</li>\n<li><p>Transformation is performed by this order:</p>\n<ol>\n<li>Translate [-el.origin[0], -el.origin[1]].</li>\n<li>Scale according to el.scale.</li>\n<li>Rotate according to el.rotation.</li>\n<li>Translate back according to el.origin.</li>\n<li>Translate according to el.position.</li>\n</ol>\n</li>\n<li>Namely, scaling and rotating firstly, and then translate. By this mechanism, translation does not affect origin of scale and rotation.</li>\n</ul>\n<p><br></p>\n<hr>\n<p><strong>Relatively Positioning</strong></p>\n<p>In real application, size of a container is always not fixed. So mechanism of relative position is required. In <code class=\"codespan\">graphic</code> component, <a href=\"#graphic.elements.left\">left</a> / <a href=\"#graphic.elements.right\">right</a> / <a href=\"#graphic.elements.top\">top</a> / <a href=\"#graphic.elements.bottom\">bottom</a> / <a href=\"#graphic.elements.width\">width</a> / <a href=\"#graphic.elements.height\">height</a> are used to position element relatively.</p>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{ // Position the image at the bottom center of its container.\n    type: &#39;image&#39;,\n    left: &#39;center&#39;, // Position at the center horizontally.\n    bottom: &#39;10%&#39;,  // Position beyond the bottom boundary 10%.\n    style: {\n        image: &#39;http://xxx.xxx.xxx/a.png&#39;,\n        width: 45,\n        height: 45\n    }\n},\n{ // Position the entire rotated group at the right-bottom corner of its container.\n    type: &#39;group&#39;,\n    right: 0,  // Position at the right boundary.\n    bottom: 0, // Position at the bottom boundary.\n    rotation: Math.PI / 4,\n    children: [\n        {\n            type: &#39;rect&#39;,\n            left: &#39;center&#39;, // Position at horizontal center according to its parent.\n            top: &#39;middle&#39;,  // Position at vertical center according to its parent.\n            shape: {\n                width: 190,\n                height: 90\n            },\n            style: {\n                fill: &#39;#fff&#39;,\n                stroke: &#39;#999&#39;,\n                lineWidth: 2,\n                shadowBlur: 8,\n                shadowOffsetX: 3,\n                shadowOffsetY: 3,\n                shadowColor: &#39;rgba(0,0,0,0.3)&#39;\n            }\n        },\n        {\n            type: &#39;text&#39;,\n            left: &#39;center&#39;, // Position at horizontal center according to its parent.\n            top: &#39;middle&#39;,  // Position at vertical center according to its parent.\n            style: {\n                fill: &#39;#777&#39;,\n                text: [\n                    &#39;This is text&#39;,\n                    &#39;This is text&#39;,\n                    &#39;Print some text&#39;\n                ].join(&#39;\\n&#39;),\n                font: &#39;14px Microsoft YaHei&#39;\n            }\n        }\n    ]\n}\n</code></pre>\n<p>Note, <a href=\"graphic.elements.bounding\" target=\"_blank\">bounding</a> can be used to specify whether the entire transformed element (containing children if is group) is confined in its container.</p>\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"elements":{"type":"Array","items":{"anyOf":[{"type":["Object"],"description":"<p><code class=\"codespan\">group</code> is the only type that can contain children, so that a group of elements can be positioned and transformed together.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#graphic.elements-image\">image</a>,\n<a href=\"#graphic.elements-text\">text</a>,\n<a href=\"#graphic.elements-circle\">circle</a>,\n<a href=\"#graphic.elements-sector\">sector</a>,\n<a href=\"#graphic.elements-ring\">ring</a>,\n<a href=\"#graphic.elements-polygon\">polygon</a>,\n<a href=\"#graphic.elements-polyline\">polyline</a>,\n<a href=\"#graphic.elements-rect\">rect</a>,\n<a href=\"#graphic.elements-line\">line</a>,\n<a href=\"#graphic.elements-bezierCurve\">bezierCurve</a>,\n<a href=\"#graphic.elements-arc\">arc</a>,\n<a href=\"#graphic.elements-group\">group</a>,</p>\n","default":"group"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"$action":{"type":["string"],"description":"<p>Specify the operation should be performed to the element when calling <code class=\"codespan\">setOption</code>.\nDefault value is &#39;merge&#39;, other values can be &#39;replace&#39; or &#39;remove&#39;.</p>\n<p>Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;merge&#39;</code>: merge the given option to existing element (if any), otherwise create a new element.</li>\n<li><code class=\"codespan\">&#39;replace&#39;</code>: create a new element according to the given option and replace the existing element (if any).</li>\n<li><code class=\"codespan\">&#39;remove&#39;</code>: delete the existing element (if any).</li>\n</ul>\n","default":"'merge'"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-group.x\">x</a> and <a href=\"#graphic.elements-group.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-group.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-group.scaleX\">scaleX</a> and <a href=\"#graphic.elements-group.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-group.originX\">originX</a> and <a href=\"#graphic.elements-group.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-group.x\">x</a> and <a href=\"#graphic.elements-group.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-group.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-group.scaleX\">scaleX</a> and <a href=\"#graphic.elements-group.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-group.originX\">originX</a> and <a href=\"#graphic.elements-group.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-group.x\">x</a> and <a href=\"#graphic.elements-group.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-group.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-group.scaleX\">scaleX</a> and <a href=\"#graphic.elements-group.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-group.originX\">originX</a> and <a href=\"#graphic.elements-group.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-group.x\">x</a> and <a href=\"#graphic.elements-group.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-group.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-group.scaleX\">scaleX</a> and <a href=\"#graphic.elements-group.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-group.originX\">originX</a> and <a href=\"#graphic.elements-group.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-group.x\">x</a> and <a href=\"#graphic.elements-group.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-group.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-group.scaleX\">scaleX</a> and <a href=\"#graphic.elements-group.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-group.originX\">originX</a> and <a href=\"#graphic.elements-group.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-group.x\">x</a> and <a href=\"#graphic.elements-group.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-group.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-group.scaleX\">scaleX</a> and <a href=\"#graphic.elements-group.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-group.originX\">originX</a> and <a href=\"#graphic.elements-group.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-group.x\">x</a> and <a href=\"#graphic.elements-group.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-group.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-group.scaleX\">scaleX</a> and <a href=\"#graphic.elements-group.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-group.originX\">originX</a> and <a href=\"#graphic.elements-group.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"left":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-group.left\">left</a> and <a href=\"#graphic.elements-group.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-group.left\">left</a> or <a href=\"#graphic.elements-group.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-group.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"right":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-group.left\">left</a> and <a href=\"#graphic.elements-group.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-group.left\">left</a> or <a href=\"#graphic.elements-group.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-group.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"top":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-group.top\">top</a> and <a href=\"#graphic.elements-group.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-group.top\">top</a> or <a href=\"#graphic.elements-group.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-group.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bottom":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-group.top\">top</a> and <a href=\"#graphic.elements-group.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-group.top\">top</a> or <a href=\"#graphic.elements-group.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-group.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bounding":{"type":["string"],"description":"<p>Used to specify whether the entire transformed element (containing children if is group) is confined in its container.</p>\n<p>See sample:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/graphic-bounding&edit=1&reset=1\" width=\"500\" height=\"500\"></iframe>\n\n\n<p>Optional values:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;all&#39;</code>: (default)\n  Use the transformed bounding box of itself and its descendants to perform position calculation, which confine the entire body in the boundary of its parent.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;raw&#39;</code>:\n  Only use the untransformed bounding box of itself (without its descentant) to perform position calculation, which is suitable when the content in the element need to be overflow its parent.</p>\n</li>\n</ul>\n","default":"'all'"},"z":{"type":["number"],"description":"<p>z value of the elements, determine the overlap order.</p>\n","default":0},"zlevel":{"type":["number"],"description":"<p>Determine which canvas layer this element should be in.</p>\n<p>Notice: Multiple canvas layer may affect performance.</p>\n","default":0},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"draggable":{"type":["boolean"],"description":"<p>Can be dragged or not.</p>\n","default":false},"progressive":{"type":["boolean"],"description":"<p>Whether use progressive render to improve performance. Usually used when number of element is too large.</p>\n","default":false},"width":{"type":["number"],"description":"<p>Specify width of this <code class=\"codespan\">group</code>.</p>\n<p>This width is only used for the positioning of its children.</p>\n<p>When width is <code class=\"codespan\">0</code>, children can also be positioned according to its parent using <code class=\"codespan\">left: &#39;center&#39;</code>.</p>\n","default":0},"height":{"type":["number"],"description":"<p>Specify height of this <code class=\"codespan\">group</code>.</p>\n<p>This height is only used for the positioning of its children.</p>\n<p>When height is <code class=\"codespan\">0</code>, children can also be positioned according to its parent using <code class=\"codespan\">top: &#39;middle&#39;</code>.</p>\n","default":0},"diffChildrenByName":{"type":["boolean"],"description":"<p>In <a href=\"#series-custom\">custom series</a>, when <code class=\"codespan\">diffChildrenByName</code> is set as <code class=\"codespan\">true</code>, for each <a href=\"#graphic.elements-group\">group</a> returned from <a href=\"#series-custom.renderItem\">renderItem</a>, &quot;diff&quot; will be performed to its <a href=\"#graphic.elements-group.children\">children</a> according to the <a href=\"#graphic.elements-polygon.name\">name</a> attribute of each graphic elements. Here &quot;diff&quot; means that map the coming graphic elements to the existing graphic elements when repainting according to <code class=\"codespan\">name</code>, which enables the transition animation if data is modified.</p>\n<p>But notice that the operation is performance consuming, do not use it for large data amount.</p>\n","default":false},"children":{"type":["Array"],"description":"<p>A list of children, each item is a declaration of an element.</p>\n"},"onclick":{"type":["Function"],"description":""},"onmouseover":{"type":["Function"],"description":""},"onmouseout":{"type":["Function"],"description":""},"onmousemove":{"type":["Function"],"description":""},"onmousewheel":{"type":["Function"],"description":""},"onmousedown":{"type":["Function"],"description":""},"onmouseup":{"type":["Function"],"description":""},"ondrag":{"type":["Function"],"description":""},"ondragstart":{"type":["Function"],"description":""},"ondragend":{"type":["Function"],"description":""},"ondragenter":{"type":["Function"],"description":""},"ondragleave":{"type":["Function"],"description":""},"ondragover":{"type":["Function"],"description":""},"ondrop":{"type":["Function"],"description":""}}},{"type":["Object"],"description":"","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#graphic.elements-image\">image</a>,\n<a href=\"#graphic.elements-text\">text</a>,\n<a href=\"#graphic.elements-circle\">circle</a>,\n<a href=\"#graphic.elements-sector\">sector</a>,\n<a href=\"#graphic.elements-ring\">ring</a>,\n<a href=\"#graphic.elements-polygon\">polygon</a>,\n<a href=\"#graphic.elements-polyline\">polyline</a>,\n<a href=\"#graphic.elements-rect\">rect</a>,\n<a href=\"#graphic.elements-line\">line</a>,\n<a href=\"#graphic.elements-bezierCurve\">bezierCurve</a>,\n<a href=\"#graphic.elements-arc\">arc</a>,\n<a href=\"#graphic.elements-group\">group</a>,</p>\n","default":"image"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"$action":{"type":["string"],"description":"<p>Specify the operation should be performed to the element when calling <code class=\"codespan\">setOption</code>.\nDefault value is &#39;merge&#39;, other values can be &#39;replace&#39; or &#39;remove&#39;.</p>\n<p>Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;merge&#39;</code>: merge the given option to existing element (if any), otherwise create a new element.</li>\n<li><code class=\"codespan\">&#39;replace&#39;</code>: create a new element according to the given option and replace the existing element (if any).</li>\n<li><code class=\"codespan\">&#39;remove&#39;</code>: delete the existing element (if any).</li>\n</ul>\n","default":"'merge'"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-image.x\">x</a> and <a href=\"#graphic.elements-image.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-image.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-image.scaleX\">scaleX</a> and <a href=\"#graphic.elements-image.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-image.originX\">originX</a> and <a href=\"#graphic.elements-image.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-image.x\">x</a> and <a href=\"#graphic.elements-image.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-image.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-image.scaleX\">scaleX</a> and <a href=\"#graphic.elements-image.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-image.originX\">originX</a> and <a href=\"#graphic.elements-image.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-image.x\">x</a> and <a href=\"#graphic.elements-image.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-image.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-image.scaleX\">scaleX</a> and <a href=\"#graphic.elements-image.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-image.originX\">originX</a> and <a href=\"#graphic.elements-image.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-image.x\">x</a> and <a href=\"#graphic.elements-image.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-image.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-image.scaleX\">scaleX</a> and <a href=\"#graphic.elements-image.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-image.originX\">originX</a> and <a href=\"#graphic.elements-image.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-image.x\">x</a> and <a href=\"#graphic.elements-image.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-image.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-image.scaleX\">scaleX</a> and <a href=\"#graphic.elements-image.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-image.originX\">originX</a> and <a href=\"#graphic.elements-image.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-image.x\">x</a> and <a href=\"#graphic.elements-image.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-image.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-image.scaleX\">scaleX</a> and <a href=\"#graphic.elements-image.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-image.originX\">originX</a> and <a href=\"#graphic.elements-image.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-image.x\">x</a> and <a href=\"#graphic.elements-image.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-image.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-image.scaleX\">scaleX</a> and <a href=\"#graphic.elements-image.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-image.originX\">originX</a> and <a href=\"#graphic.elements-image.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"left":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-image.left\">left</a> and <a href=\"#graphic.elements-image.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-image.left\">left</a> or <a href=\"#graphic.elements-image.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-image.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"right":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-image.left\">left</a> and <a href=\"#graphic.elements-image.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-image.left\">left</a> or <a href=\"#graphic.elements-image.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-image.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"top":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-image.top\">top</a> and <a href=\"#graphic.elements-image.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-image.top\">top</a> or <a href=\"#graphic.elements-image.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-image.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bottom":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-image.top\">top</a> and <a href=\"#graphic.elements-image.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-image.top\">top</a> or <a href=\"#graphic.elements-image.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-image.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bounding":{"type":["string"],"description":"<p>Used to specify whether the entire transformed element (containing children if is group) is confined in its container.</p>\n<p>See sample:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/graphic-bounding&edit=1&reset=1\" width=\"500\" height=\"500\"></iframe>\n\n\n<p>Optional values:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;all&#39;</code>: (default)\n  Use the transformed bounding box of itself and its descendants to perform position calculation, which confine the entire body in the boundary of its parent.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;raw&#39;</code>:\n  Only use the untransformed bounding box of itself (without its descentant) to perform position calculation, which is suitable when the content in the element need to be overflow its parent.</p>\n</li>\n</ul>\n","default":"'all'"},"z":{"type":["number"],"description":"<p>z value of the elements, determine the overlap order.</p>\n","default":0},"zlevel":{"type":["number"],"description":"<p>Determine which canvas layer this element should be in.</p>\n<p>Notice: Multiple canvas layer may affect performance.</p>\n","default":0},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"draggable":{"type":["boolean"],"description":"<p>Can be dragged or not.</p>\n","default":false},"progressive":{"type":["boolean"],"description":"<p>Whether use progressive render to improve performance. Usually used when number of element is too large.</p>\n","default":false},"style":{"type":["Object"],"description":"","properties":{"image":{"type":["string"],"description":"<p>Specify content of the image, can be a URL, or <a href=\"https://tools.ietf.org/html/rfc2397\" target=\"_blank\">dataURI</a>.</p>\n"},"x":{"type":["number"],"description":"<p>The x value of the left-top corner of the element in the coordinate system of its parent.</p>\n","default":0},"y":{"type":["number"],"description":"<p>The y value of the left-top corner of the element in the coordinate system of its parent.</p>\n","default":0},"width":{"type":["number"],"description":"<p>The width of the shape of the element.</p>\n","default":0},"height":{"type":["numbr"],"description":"<p>The height of the shape of the element.</p>\n<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","default":0},"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"}}},"onclick":{"type":["Function"],"description":""},"onmouseover":{"type":["Function"],"description":""},"onmouseout":{"type":["Function"],"description":""},"onmousemove":{"type":["Function"],"description":""},"onmousewheel":{"type":["Function"],"description":""},"onmousedown":{"type":["Function"],"description":""},"onmouseup":{"type":["Function"],"description":""},"ondrag":{"type":["Function"],"description":""},"ondragstart":{"type":["Function"],"description":""},"ondragend":{"type":["Function"],"description":""},"ondragenter":{"type":["Function"],"description":""},"ondragleave":{"type":["Function"],"description":""},"ondragover":{"type":["Function"],"description":""},"ondrop":{"type":["Function"],"description":""}}},{"type":["Object"],"description":"<p>Text block.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#graphic.elements-image\">image</a>,\n<a href=\"#graphic.elements-text\">text</a>,\n<a href=\"#graphic.elements-circle\">circle</a>,\n<a href=\"#graphic.elements-sector\">sector</a>,\n<a href=\"#graphic.elements-ring\">ring</a>,\n<a href=\"#graphic.elements-polygon\">polygon</a>,\n<a href=\"#graphic.elements-polyline\">polyline</a>,\n<a href=\"#graphic.elements-rect\">rect</a>,\n<a href=\"#graphic.elements-line\">line</a>,\n<a href=\"#graphic.elements-bezierCurve\">bezierCurve</a>,\n<a href=\"#graphic.elements-arc\">arc</a>,\n<a href=\"#graphic.elements-group\">group</a>,</p>\n","default":"text"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"$action":{"type":["string"],"description":"<p>Specify the operation should be performed to the element when calling <code class=\"codespan\">setOption</code>.\nDefault value is &#39;merge&#39;, other values can be &#39;replace&#39; or &#39;remove&#39;.</p>\n<p>Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;merge&#39;</code>: merge the given option to existing element (if any), otherwise create a new element.</li>\n<li><code class=\"codespan\">&#39;replace&#39;</code>: create a new element according to the given option and replace the existing element (if any).</li>\n<li><code class=\"codespan\">&#39;remove&#39;</code>: delete the existing element (if any).</li>\n</ul>\n","default":"'merge'"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-text.x\">x</a> and <a href=\"#graphic.elements-text.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-text.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-text.scaleX\">scaleX</a> and <a href=\"#graphic.elements-text.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-text.originX\">originX</a> and <a href=\"#graphic.elements-text.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-text.x\">x</a> and <a href=\"#graphic.elements-text.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-text.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-text.scaleX\">scaleX</a> and <a href=\"#graphic.elements-text.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-text.originX\">originX</a> and <a href=\"#graphic.elements-text.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-text.x\">x</a> and <a href=\"#graphic.elements-text.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-text.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-text.scaleX\">scaleX</a> and <a href=\"#graphic.elements-text.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-text.originX\">originX</a> and <a href=\"#graphic.elements-text.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-text.x\">x</a> and <a href=\"#graphic.elements-text.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-text.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-text.scaleX\">scaleX</a> and <a href=\"#graphic.elements-text.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-text.originX\">originX</a> and <a href=\"#graphic.elements-text.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-text.x\">x</a> and <a href=\"#graphic.elements-text.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-text.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-text.scaleX\">scaleX</a> and <a href=\"#graphic.elements-text.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-text.originX\">originX</a> and <a href=\"#graphic.elements-text.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-text.x\">x</a> and <a href=\"#graphic.elements-text.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-text.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-text.scaleX\">scaleX</a> and <a href=\"#graphic.elements-text.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-text.originX\">originX</a> and <a href=\"#graphic.elements-text.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-text.x\">x</a> and <a href=\"#graphic.elements-text.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-text.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-text.scaleX\">scaleX</a> and <a href=\"#graphic.elements-text.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-text.originX\">originX</a> and <a href=\"#graphic.elements-text.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"left":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-text.left\">left</a> and <a href=\"#graphic.elements-text.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-text.left\">left</a> or <a href=\"#graphic.elements-text.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-text.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"right":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-text.left\">left</a> and <a href=\"#graphic.elements-text.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-text.left\">left</a> or <a href=\"#graphic.elements-text.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-text.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"top":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-text.top\">top</a> and <a href=\"#graphic.elements-text.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-text.top\">top</a> or <a href=\"#graphic.elements-text.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-text.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bottom":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-text.top\">top</a> and <a href=\"#graphic.elements-text.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-text.top\">top</a> or <a href=\"#graphic.elements-text.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-text.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bounding":{"type":["string"],"description":"<p>Used to specify whether the entire transformed element (containing children if is group) is confined in its container.</p>\n<p>See sample:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/graphic-bounding&edit=1&reset=1\" width=\"500\" height=\"500\"></iframe>\n\n\n<p>Optional values:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;all&#39;</code>: (default)\n  Use the transformed bounding box of itself and its descendants to perform position calculation, which confine the entire body in the boundary of its parent.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;raw&#39;</code>:\n  Only use the untransformed bounding box of itself (without its descentant) to perform position calculation, which is suitable when the content in the element need to be overflow its parent.</p>\n</li>\n</ul>\n","default":"'all'"},"z":{"type":["number"],"description":"<p>z value of the elements, determine the overlap order.</p>\n","default":0},"zlevel":{"type":["number"],"description":"<p>Determine which canvas layer this element should be in.</p>\n<p>Notice: Multiple canvas layer may affect performance.</p>\n","default":0},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"draggable":{"type":["boolean"],"description":"<p>Can be dragged or not.</p>\n","default":false},"progressive":{"type":["boolean"],"description":"<p>Whether use progressive render to improve performance. Usually used when number of element is too large.</p>\n","default":false},"style":{"type":["Object"],"description":"","properties":{"text":{"type":["string"],"description":"<p>Text content. <code class=\"codespan\">\\n</code> can be used as a line break.</p>\n","default":"''"},"x":{"type":["number"],"description":"<p>The x value of the left-top corner of the element in the coordinate system of its parent.</p>\n","default":0},"y":{"type":["number"],"description":"<p>The y value of the left-top corner of the element in the coordinate system of its parent.</p>\n","default":0},"font":{"type":["string"],"description":"<p>Font size, font type, font weight, font color, follow the form of <a href=\"https://developer.mozilla.org/en-US/docs/Web/CSS/font\" target=\"_blank\">css font</a>.</p>\n<p>For example:</p>\n<pre><code>// size | family\nfont: &#39;2em &quot;STHeiti&quot;, sans-serif&#39;\n\n// style | weight | size | family\nfont: &#39;italic bolder 16px cursive&#39;\n\n// weight | size | family\nfont: &#39;bolder 2em &quot;Microsoft YaHei&quot;, sans-serif&#39;\n</code></pre>"},"textAlign":{"type":["string"],"description":"<p>Text horizontal alignment. Optional values: <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;left&#39;</code> means the left side of the text block is specified by the <a href=\"#graphic.elements-text.style.x\">style.x</a>, while <code class=\"codespan\">&#39;right&#39;</code> means the right side of the text block is specified by <a href=\"#graphic.elements-text.style.y\">style.y</a>.</p>\n","default":"'left'"},"textVerticalAlign":{"type":["string"],"description":"<p>Text vertical alignment. Optional values: <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n"},"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"}}},"onclick":{"type":["Function"],"description":""},"onmouseover":{"type":["Function"],"description":""},"onmouseout":{"type":["Function"],"description":""},"onmousemove":{"type":["Function"],"description":""},"onmousewheel":{"type":["Function"],"description":""},"onmousedown":{"type":["Function"],"description":""},"onmouseup":{"type":["Function"],"description":""},"ondrag":{"type":["Function"],"description":""},"ondragstart":{"type":["Function"],"description":""},"ondragend":{"type":["Function"],"description":""},"ondragenter":{"type":["Function"],"description":""},"ondragleave":{"type":["Function"],"description":""},"ondragover":{"type":["Function"],"description":""},"ondrop":{"type":["Function"],"description":""}}},{"type":["Object"],"description":"<p>Rectangle element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#graphic.elements-image\">image</a>,\n<a href=\"#graphic.elements-text\">text</a>,\n<a href=\"#graphic.elements-circle\">circle</a>,\n<a href=\"#graphic.elements-sector\">sector</a>,\n<a href=\"#graphic.elements-ring\">ring</a>,\n<a href=\"#graphic.elements-polygon\">polygon</a>,\n<a href=\"#graphic.elements-polyline\">polyline</a>,\n<a href=\"#graphic.elements-rect\">rect</a>,\n<a href=\"#graphic.elements-line\">line</a>,\n<a href=\"#graphic.elements-bezierCurve\">bezierCurve</a>,\n<a href=\"#graphic.elements-arc\">arc</a>,\n<a href=\"#graphic.elements-group\">group</a>,</p>\n","default":"rect"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"$action":{"type":["string"],"description":"<p>Specify the operation should be performed to the element when calling <code class=\"codespan\">setOption</code>.\nDefault value is &#39;merge&#39;, other values can be &#39;replace&#39; or &#39;remove&#39;.</p>\n<p>Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;merge&#39;</code>: merge the given option to existing element (if any), otherwise create a new element.</li>\n<li><code class=\"codespan\">&#39;replace&#39;</code>: create a new element according to the given option and replace the existing element (if any).</li>\n<li><code class=\"codespan\">&#39;remove&#39;</code>: delete the existing element (if any).</li>\n</ul>\n","default":"'merge'"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-rect.x\">x</a> and <a href=\"#graphic.elements-rect.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-rect.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-rect.scaleX\">scaleX</a> and <a href=\"#graphic.elements-rect.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-rect.originX\">originX</a> and <a href=\"#graphic.elements-rect.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-rect.x\">x</a> and <a href=\"#graphic.elements-rect.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-rect.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-rect.scaleX\">scaleX</a> and <a href=\"#graphic.elements-rect.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-rect.originX\">originX</a> and <a href=\"#graphic.elements-rect.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-rect.x\">x</a> and <a href=\"#graphic.elements-rect.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-rect.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-rect.scaleX\">scaleX</a> and <a href=\"#graphic.elements-rect.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-rect.originX\">originX</a> and <a href=\"#graphic.elements-rect.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-rect.x\">x</a> and <a href=\"#graphic.elements-rect.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-rect.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-rect.scaleX\">scaleX</a> and <a href=\"#graphic.elements-rect.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-rect.originX\">originX</a> and <a href=\"#graphic.elements-rect.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-rect.x\">x</a> and <a href=\"#graphic.elements-rect.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-rect.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-rect.scaleX\">scaleX</a> and <a href=\"#graphic.elements-rect.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-rect.originX\">originX</a> and <a href=\"#graphic.elements-rect.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-rect.x\">x</a> and <a href=\"#graphic.elements-rect.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-rect.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-rect.scaleX\">scaleX</a> and <a href=\"#graphic.elements-rect.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-rect.originX\">originX</a> and <a href=\"#graphic.elements-rect.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-rect.x\">x</a> and <a href=\"#graphic.elements-rect.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-rect.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-rect.scaleX\">scaleX</a> and <a href=\"#graphic.elements-rect.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-rect.originX\">originX</a> and <a href=\"#graphic.elements-rect.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"left":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-rect.left\">left</a> and <a href=\"#graphic.elements-rect.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-rect.left\">left</a> or <a href=\"#graphic.elements-rect.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-rect.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"right":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-rect.left\">left</a> and <a href=\"#graphic.elements-rect.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-rect.left\">left</a> or <a href=\"#graphic.elements-rect.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-rect.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"top":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-rect.top\">top</a> and <a href=\"#graphic.elements-rect.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-rect.top\">top</a> or <a href=\"#graphic.elements-rect.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-rect.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bottom":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-rect.top\">top</a> and <a href=\"#graphic.elements-rect.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-rect.top\">top</a> or <a href=\"#graphic.elements-rect.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-rect.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bounding":{"type":["string"],"description":"<p>Used to specify whether the entire transformed element (containing children if is group) is confined in its container.</p>\n<p>See sample:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/graphic-bounding&edit=1&reset=1\" width=\"500\" height=\"500\"></iframe>\n\n\n<p>Optional values:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;all&#39;</code>: (default)\n  Use the transformed bounding box of itself and its descendants to perform position calculation, which confine the entire body in the boundary of its parent.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;raw&#39;</code>:\n  Only use the untransformed bounding box of itself (without its descentant) to perform position calculation, which is suitable when the content in the element need to be overflow its parent.</p>\n</li>\n</ul>\n","default":"'all'"},"z":{"type":["number"],"description":"<p>z value of the elements, determine the overlap order.</p>\n","default":0},"zlevel":{"type":["number"],"description":"<p>Determine which canvas layer this element should be in.</p>\n<p>Notice: Multiple canvas layer may affect performance.</p>\n","default":0},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"draggable":{"type":["boolean"],"description":"<p>Can be dragged or not.</p>\n","default":false},"progressive":{"type":["boolean"],"description":"<p>Whether use progressive render to improve performance. Usually used when number of element is too large.</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"x":{"type":["number"],"description":"<p>The x value of the left-top corner of the element in the coordinate system of its parent.</p>\n","default":0},"y":{"type":["number"],"description":"<p>The y value of the left-top corner of the element in the coordinate system of its parent.</p>\n","default":0},"width":{"type":["number"],"description":"<p>The width of the shape of the element.</p>\n","default":0},"height":{"type":["numbr"],"description":"<p>The height of the shape of the element.</p>\n","default":0},"r":{"type":["Array"],"description":"<p>Specify border radius of the rectangular here. Generally, <code class=\"codespan\">r</code> should be <code class=\"codespan\">[topLeftRadius, topRightRadius, BottomRightRadius, bottomLeftRadius]</code>, where each item is a number.</p>\n<p>Abbreviation is enabled, for example:</p>\n<ul>\n<li><code class=\"codespan\">r</code>: <code class=\"codespan\">1</code>         means <code class=\"codespan\">[1, 1, 1, 1]</code></li>\n<li><code class=\"codespan\">r</code>: <code class=\"codespan\">[1]</code>       means <code class=\"codespan\">[1, 1, 1, 1]</code></li>\n<li><code class=\"codespan\">r</code>: <code class=\"codespan\">[1, 2]</code>    means <code class=\"codespan\">[1, 2, 1, 2]</code></li>\n<li><code class=\"codespan\">r</code>: <code class=\"codespan\">[1, 2, 3]</code> means <code class=\"codespan\">[1, 2, 3, 2]</code></li>\n</ul>\n"}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"}}},"onclick":{"type":["Function"],"description":""},"onmouseover":{"type":["Function"],"description":""},"onmouseout":{"type":["Function"],"description":""},"onmousemove":{"type":["Function"],"description":""},"onmousewheel":{"type":["Function"],"description":""},"onmousedown":{"type":["Function"],"description":""},"onmouseup":{"type":["Function"],"description":""},"ondrag":{"type":["Function"],"description":""},"ondragstart":{"type":["Function"],"description":""},"ondragend":{"type":["Function"],"description":""},"ondragenter":{"type":["Function"],"description":""},"ondragleave":{"type":["Function"],"description":""},"ondragover":{"type":["Function"],"description":""},"ondrop":{"type":["Function"],"description":""}}},{"type":["Object"],"description":"<p>Circle element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#graphic.elements-image\">image</a>,\n<a href=\"#graphic.elements-text\">text</a>,\n<a href=\"#graphic.elements-circle\">circle</a>,\n<a href=\"#graphic.elements-sector\">sector</a>,\n<a href=\"#graphic.elements-ring\">ring</a>,\n<a href=\"#graphic.elements-polygon\">polygon</a>,\n<a href=\"#graphic.elements-polyline\">polyline</a>,\n<a href=\"#graphic.elements-rect\">rect</a>,\n<a href=\"#graphic.elements-line\">line</a>,\n<a href=\"#graphic.elements-bezierCurve\">bezierCurve</a>,\n<a href=\"#graphic.elements-arc\">arc</a>,\n<a href=\"#graphic.elements-group\">group</a>,</p>\n","default":"circle"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"$action":{"type":["string"],"description":"<p>Specify the operation should be performed to the element when calling <code class=\"codespan\">setOption</code>.\nDefault value is &#39;merge&#39;, other values can be &#39;replace&#39; or &#39;remove&#39;.</p>\n<p>Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;merge&#39;</code>: merge the given option to existing element (if any), otherwise create a new element.</li>\n<li><code class=\"codespan\">&#39;replace&#39;</code>: create a new element according to the given option and replace the existing element (if any).</li>\n<li><code class=\"codespan\">&#39;remove&#39;</code>: delete the existing element (if any).</li>\n</ul>\n","default":"'merge'"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-circle.x\">x</a> and <a href=\"#graphic.elements-circle.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-circle.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-circle.scaleX\">scaleX</a> and <a href=\"#graphic.elements-circle.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-circle.originX\">originX</a> and <a href=\"#graphic.elements-circle.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-circle.x\">x</a> and <a href=\"#graphic.elements-circle.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-circle.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-circle.scaleX\">scaleX</a> and <a href=\"#graphic.elements-circle.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-circle.originX\">originX</a> and <a href=\"#graphic.elements-circle.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-circle.x\">x</a> and <a href=\"#graphic.elements-circle.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-circle.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-circle.scaleX\">scaleX</a> and <a href=\"#graphic.elements-circle.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-circle.originX\">originX</a> and <a href=\"#graphic.elements-circle.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-circle.x\">x</a> and <a href=\"#graphic.elements-circle.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-circle.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-circle.scaleX\">scaleX</a> and <a href=\"#graphic.elements-circle.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-circle.originX\">originX</a> and <a href=\"#graphic.elements-circle.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-circle.x\">x</a> and <a href=\"#graphic.elements-circle.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-circle.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-circle.scaleX\">scaleX</a> and <a href=\"#graphic.elements-circle.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-circle.originX\">originX</a> and <a href=\"#graphic.elements-circle.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-circle.x\">x</a> and <a href=\"#graphic.elements-circle.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-circle.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-circle.scaleX\">scaleX</a> and <a href=\"#graphic.elements-circle.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-circle.originX\">originX</a> and <a href=\"#graphic.elements-circle.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-circle.x\">x</a> and <a href=\"#graphic.elements-circle.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-circle.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-circle.scaleX\">scaleX</a> and <a href=\"#graphic.elements-circle.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-circle.originX\">originX</a> and <a href=\"#graphic.elements-circle.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"left":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-circle.left\">left</a> and <a href=\"#graphic.elements-circle.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-circle.left\">left</a> or <a href=\"#graphic.elements-circle.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-circle.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"right":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-circle.left\">left</a> and <a href=\"#graphic.elements-circle.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-circle.left\">left</a> or <a href=\"#graphic.elements-circle.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-circle.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"top":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-circle.top\">top</a> and <a href=\"#graphic.elements-circle.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-circle.top\">top</a> or <a href=\"#graphic.elements-circle.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-circle.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bottom":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-circle.top\">top</a> and <a href=\"#graphic.elements-circle.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-circle.top\">top</a> or <a href=\"#graphic.elements-circle.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-circle.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bounding":{"type":["string"],"description":"<p>Used to specify whether the entire transformed element (containing children if is group) is confined in its container.</p>\n<p>See sample:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/graphic-bounding&edit=1&reset=1\" width=\"500\" height=\"500\"></iframe>\n\n\n<p>Optional values:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;all&#39;</code>: (default)\n  Use the transformed bounding box of itself and its descendants to perform position calculation, which confine the entire body in the boundary of its parent.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;raw&#39;</code>:\n  Only use the untransformed bounding box of itself (without its descentant) to perform position calculation, which is suitable when the content in the element need to be overflow its parent.</p>\n</li>\n</ul>\n","default":"'all'"},"z":{"type":["number"],"description":"<p>z value of the elements, determine the overlap order.</p>\n","default":0},"zlevel":{"type":["number"],"description":"<p>Determine which canvas layer this element should be in.</p>\n<p>Notice: Multiple canvas layer may affect performance.</p>\n","default":0},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"draggable":{"type":["boolean"],"description":"<p>Can be dragged or not.</p>\n","default":false},"progressive":{"type":["boolean"],"description":"<p>Whether use progressive render to improve performance. Usually used when number of element is too large.</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"cx":{"type":["number"],"description":"<p>The x value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"cy":{"type":["numbr"],"description":"<p>The y value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"r":{"type":["number"],"description":"<p>Outside radius.</p>\n","default":0}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"}}},"onclick":{"type":["Function"],"description":""},"onmouseover":{"type":["Function"],"description":""},"onmouseout":{"type":["Function"],"description":""},"onmousemove":{"type":["Function"],"description":""},"onmousewheel":{"type":["Function"],"description":""},"onmousedown":{"type":["Function"],"description":""},"onmouseup":{"type":["Function"],"description":""},"ondrag":{"type":["Function"],"description":""},"ondragstart":{"type":["Function"],"description":""},"ondragend":{"type":["Function"],"description":""},"ondragenter":{"type":["Function"],"description":""},"ondragleave":{"type":["Function"],"description":""},"ondragover":{"type":["Function"],"description":""},"ondrop":{"type":["Function"],"description":""}}},{"type":["Object"],"description":"<p>Ring element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#graphic.elements-image\">image</a>,\n<a href=\"#graphic.elements-text\">text</a>,\n<a href=\"#graphic.elements-circle\">circle</a>,\n<a href=\"#graphic.elements-sector\">sector</a>,\n<a href=\"#graphic.elements-ring\">ring</a>,\n<a href=\"#graphic.elements-polygon\">polygon</a>,\n<a href=\"#graphic.elements-polyline\">polyline</a>,\n<a href=\"#graphic.elements-rect\">rect</a>,\n<a href=\"#graphic.elements-line\">line</a>,\n<a href=\"#graphic.elements-bezierCurve\">bezierCurve</a>,\n<a href=\"#graphic.elements-arc\">arc</a>,\n<a href=\"#graphic.elements-group\">group</a>,</p>\n","default":"ring"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"$action":{"type":["string"],"description":"<p>Specify the operation should be performed to the element when calling <code class=\"codespan\">setOption</code>.\nDefault value is &#39;merge&#39;, other values can be &#39;replace&#39; or &#39;remove&#39;.</p>\n<p>Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;merge&#39;</code>: merge the given option to existing element (if any), otherwise create a new element.</li>\n<li><code class=\"codespan\">&#39;replace&#39;</code>: create a new element according to the given option and replace the existing element (if any).</li>\n<li><code class=\"codespan\">&#39;remove&#39;</code>: delete the existing element (if any).</li>\n</ul>\n","default":"'merge'"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-ring.x\">x</a> and <a href=\"#graphic.elements-ring.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-ring.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-ring.scaleX\">scaleX</a> and <a href=\"#graphic.elements-ring.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-ring.originX\">originX</a> and <a href=\"#graphic.elements-ring.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-ring.x\">x</a> and <a href=\"#graphic.elements-ring.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-ring.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-ring.scaleX\">scaleX</a> and <a href=\"#graphic.elements-ring.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-ring.originX\">originX</a> and <a href=\"#graphic.elements-ring.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-ring.x\">x</a> and <a href=\"#graphic.elements-ring.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-ring.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-ring.scaleX\">scaleX</a> and <a href=\"#graphic.elements-ring.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-ring.originX\">originX</a> and <a href=\"#graphic.elements-ring.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-ring.x\">x</a> and <a href=\"#graphic.elements-ring.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-ring.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-ring.scaleX\">scaleX</a> and <a href=\"#graphic.elements-ring.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-ring.originX\">originX</a> and <a href=\"#graphic.elements-ring.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-ring.x\">x</a> and <a href=\"#graphic.elements-ring.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-ring.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-ring.scaleX\">scaleX</a> and <a href=\"#graphic.elements-ring.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-ring.originX\">originX</a> and <a href=\"#graphic.elements-ring.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-ring.x\">x</a> and <a href=\"#graphic.elements-ring.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-ring.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-ring.scaleX\">scaleX</a> and <a href=\"#graphic.elements-ring.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-ring.originX\">originX</a> and <a href=\"#graphic.elements-ring.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-ring.x\">x</a> and <a href=\"#graphic.elements-ring.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-ring.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-ring.scaleX\">scaleX</a> and <a href=\"#graphic.elements-ring.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-ring.originX\">originX</a> and <a href=\"#graphic.elements-ring.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"left":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-ring.left\">left</a> and <a href=\"#graphic.elements-ring.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-ring.left\">left</a> or <a href=\"#graphic.elements-ring.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-ring.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"right":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-ring.left\">left</a> and <a href=\"#graphic.elements-ring.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-ring.left\">left</a> or <a href=\"#graphic.elements-ring.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-ring.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"top":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-ring.top\">top</a> and <a href=\"#graphic.elements-ring.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-ring.top\">top</a> or <a href=\"#graphic.elements-ring.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-ring.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bottom":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-ring.top\">top</a> and <a href=\"#graphic.elements-ring.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-ring.top\">top</a> or <a href=\"#graphic.elements-ring.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-ring.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bounding":{"type":["string"],"description":"<p>Used to specify whether the entire transformed element (containing children if is group) is confined in its container.</p>\n<p>See sample:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/graphic-bounding&edit=1&reset=1\" width=\"500\" height=\"500\"></iframe>\n\n\n<p>Optional values:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;all&#39;</code>: (default)\n  Use the transformed bounding box of itself and its descendants to perform position calculation, which confine the entire body in the boundary of its parent.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;raw&#39;</code>:\n  Only use the untransformed bounding box of itself (without its descentant) to perform position calculation, which is suitable when the content in the element need to be overflow its parent.</p>\n</li>\n</ul>\n","default":"'all'"},"z":{"type":["number"],"description":"<p>z value of the elements, determine the overlap order.</p>\n","default":0},"zlevel":{"type":["number"],"description":"<p>Determine which canvas layer this element should be in.</p>\n<p>Notice: Multiple canvas layer may affect performance.</p>\n","default":0},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"draggable":{"type":["boolean"],"description":"<p>Can be dragged or not.</p>\n","default":false},"progressive":{"type":["boolean"],"description":"<p>Whether use progressive render to improve performance. Usually used when number of element is too large.</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"cx":{"type":["number"],"description":"<p>The x value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"cy":{"type":["numbr"],"description":"<p>The y value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"r":{"type":["number"],"description":"<p>Outside radius.</p>\n","default":0},"r0":{"type":["number"],"description":"<p>Inside radius.</p>\n","default":0}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"}}},"onclick":{"type":["Function"],"description":""},"onmouseover":{"type":["Function"],"description":""},"onmouseout":{"type":["Function"],"description":""},"onmousemove":{"type":["Function"],"description":""},"onmousewheel":{"type":["Function"],"description":""},"onmousedown":{"type":["Function"],"description":""},"onmouseup":{"type":["Function"],"description":""},"ondrag":{"type":["Function"],"description":""},"ondragstart":{"type":["Function"],"description":""},"ondragend":{"type":["Function"],"description":""},"ondragenter":{"type":["Function"],"description":""},"ondragleave":{"type":["Function"],"description":""},"ondragover":{"type":["Function"],"description":""},"ondrop":{"type":["Function"],"description":""}}},{"type":["Object"],"description":"<p>Sector element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#graphic.elements-image\">image</a>,\n<a href=\"#graphic.elements-text\">text</a>,\n<a href=\"#graphic.elements-circle\">circle</a>,\n<a href=\"#graphic.elements-sector\">sector</a>,\n<a href=\"#graphic.elements-ring\">ring</a>,\n<a href=\"#graphic.elements-polygon\">polygon</a>,\n<a href=\"#graphic.elements-polyline\">polyline</a>,\n<a href=\"#graphic.elements-rect\">rect</a>,\n<a href=\"#graphic.elements-line\">line</a>,\n<a href=\"#graphic.elements-bezierCurve\">bezierCurve</a>,\n<a href=\"#graphic.elements-arc\">arc</a>,\n<a href=\"#graphic.elements-group\">group</a>,</p>\n","default":"sector"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"$action":{"type":["string"],"description":"<p>Specify the operation should be performed to the element when calling <code class=\"codespan\">setOption</code>.\nDefault value is &#39;merge&#39;, other values can be &#39;replace&#39; or &#39;remove&#39;.</p>\n<p>Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;merge&#39;</code>: merge the given option to existing element (if any), otherwise create a new element.</li>\n<li><code class=\"codespan\">&#39;replace&#39;</code>: create a new element according to the given option and replace the existing element (if any).</li>\n<li><code class=\"codespan\">&#39;remove&#39;</code>: delete the existing element (if any).</li>\n</ul>\n","default":"'merge'"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-sector.x\">x</a> and <a href=\"#graphic.elements-sector.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-sector.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-sector.scaleX\">scaleX</a> and <a href=\"#graphic.elements-sector.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-sector.originX\">originX</a> and <a href=\"#graphic.elements-sector.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-sector.x\">x</a> and <a href=\"#graphic.elements-sector.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-sector.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-sector.scaleX\">scaleX</a> and <a href=\"#graphic.elements-sector.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-sector.originX\">originX</a> and <a href=\"#graphic.elements-sector.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-sector.x\">x</a> and <a href=\"#graphic.elements-sector.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-sector.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-sector.scaleX\">scaleX</a> and <a href=\"#graphic.elements-sector.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-sector.originX\">originX</a> and <a href=\"#graphic.elements-sector.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-sector.x\">x</a> and <a href=\"#graphic.elements-sector.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-sector.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-sector.scaleX\">scaleX</a> and <a href=\"#graphic.elements-sector.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-sector.originX\">originX</a> and <a href=\"#graphic.elements-sector.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-sector.x\">x</a> and <a href=\"#graphic.elements-sector.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-sector.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-sector.scaleX\">scaleX</a> and <a href=\"#graphic.elements-sector.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-sector.originX\">originX</a> and <a href=\"#graphic.elements-sector.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-sector.x\">x</a> and <a href=\"#graphic.elements-sector.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-sector.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-sector.scaleX\">scaleX</a> and <a href=\"#graphic.elements-sector.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-sector.originX\">originX</a> and <a href=\"#graphic.elements-sector.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-sector.x\">x</a> and <a href=\"#graphic.elements-sector.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-sector.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-sector.scaleX\">scaleX</a> and <a href=\"#graphic.elements-sector.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-sector.originX\">originX</a> and <a href=\"#graphic.elements-sector.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"left":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-sector.left\">left</a> and <a href=\"#graphic.elements-sector.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-sector.left\">left</a> or <a href=\"#graphic.elements-sector.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-sector.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"right":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-sector.left\">left</a> and <a href=\"#graphic.elements-sector.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-sector.left\">left</a> or <a href=\"#graphic.elements-sector.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-sector.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"top":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-sector.top\">top</a> and <a href=\"#graphic.elements-sector.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-sector.top\">top</a> or <a href=\"#graphic.elements-sector.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-sector.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bottom":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-sector.top\">top</a> and <a href=\"#graphic.elements-sector.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-sector.top\">top</a> or <a href=\"#graphic.elements-sector.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-sector.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bounding":{"type":["string"],"description":"<p>Used to specify whether the entire transformed element (containing children if is group) is confined in its container.</p>\n<p>See sample:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/graphic-bounding&edit=1&reset=1\" width=\"500\" height=\"500\"></iframe>\n\n\n<p>Optional values:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;all&#39;</code>: (default)\n  Use the transformed bounding box of itself and its descendants to perform position calculation, which confine the entire body in the boundary of its parent.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;raw&#39;</code>:\n  Only use the untransformed bounding box of itself (without its descentant) to perform position calculation, which is suitable when the content in the element need to be overflow its parent.</p>\n</li>\n</ul>\n","default":"'all'"},"z":{"type":["number"],"description":"<p>z value of the elements, determine the overlap order.</p>\n","default":0},"zlevel":{"type":["number"],"description":"<p>Determine which canvas layer this element should be in.</p>\n<p>Notice: Multiple canvas layer may affect performance.</p>\n","default":0},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"draggable":{"type":["boolean"],"description":"<p>Can be dragged or not.</p>\n","default":false},"progressive":{"type":["boolean"],"description":"<p>Whether use progressive render to improve performance. Usually used when number of element is too large.</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"cx":{"type":["number"],"description":"<p>The x value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"cy":{"type":["numbr"],"description":"<p>The y value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"r":{"type":["number"],"description":"<p>Outside radius.</p>\n","default":0},"r0":{"type":["number"],"description":"<p>Inside radius.</p>\n","default":0},"startAngle":{"type":["number"],"description":"<p>start angle, in radian.</p>\n","default":0},"endAngle":{"type":["number"],"description":"<p>end angle, in radian.</p>\n","default":"Math.PI * 2"},"clockwise":{"type":["boolean"],"description":"<p>Whether draw clockwise.</p>\n","default":true}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"}}},"onclick":{"type":["Function"],"description":""},"onmouseover":{"type":["Function"],"description":""},"onmouseout":{"type":["Function"],"description":""},"onmousemove":{"type":["Function"],"description":""},"onmousewheel":{"type":["Function"],"description":""},"onmousedown":{"type":["Function"],"description":""},"onmouseup":{"type":["Function"],"description":""},"ondrag":{"type":["Function"],"description":""},"ondragstart":{"type":["Function"],"description":""},"ondragend":{"type":["Function"],"description":""},"ondragenter":{"type":["Function"],"description":""},"ondragleave":{"type":["Function"],"description":""},"ondragover":{"type":["Function"],"description":""},"ondrop":{"type":["Function"],"description":""}}},{"type":["Object"],"description":"<p>Arc element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#graphic.elements-image\">image</a>,\n<a href=\"#graphic.elements-text\">text</a>,\n<a href=\"#graphic.elements-circle\">circle</a>,\n<a href=\"#graphic.elements-sector\">sector</a>,\n<a href=\"#graphic.elements-ring\">ring</a>,\n<a href=\"#graphic.elements-polygon\">polygon</a>,\n<a href=\"#graphic.elements-polyline\">polyline</a>,\n<a href=\"#graphic.elements-rect\">rect</a>,\n<a href=\"#graphic.elements-line\">line</a>,\n<a href=\"#graphic.elements-bezierCurve\">bezierCurve</a>,\n<a href=\"#graphic.elements-arc\">arc</a>,\n<a href=\"#graphic.elements-group\">group</a>,</p>\n","default":"arc"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"$action":{"type":["string"],"description":"<p>Specify the operation should be performed to the element when calling <code class=\"codespan\">setOption</code>.\nDefault value is &#39;merge&#39;, other values can be &#39;replace&#39; or &#39;remove&#39;.</p>\n<p>Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;merge&#39;</code>: merge the given option to existing element (if any), otherwise create a new element.</li>\n<li><code class=\"codespan\">&#39;replace&#39;</code>: create a new element according to the given option and replace the existing element (if any).</li>\n<li><code class=\"codespan\">&#39;remove&#39;</code>: delete the existing element (if any).</li>\n</ul>\n","default":"'merge'"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-arc.x\">x</a> and <a href=\"#graphic.elements-arc.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-arc.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-arc.scaleX\">scaleX</a> and <a href=\"#graphic.elements-arc.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-arc.originX\">originX</a> and <a href=\"#graphic.elements-arc.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-arc.x\">x</a> and <a href=\"#graphic.elements-arc.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-arc.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-arc.scaleX\">scaleX</a> and <a href=\"#graphic.elements-arc.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-arc.originX\">originX</a> and <a href=\"#graphic.elements-arc.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-arc.x\">x</a> and <a href=\"#graphic.elements-arc.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-arc.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-arc.scaleX\">scaleX</a> and <a href=\"#graphic.elements-arc.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-arc.originX\">originX</a> and <a href=\"#graphic.elements-arc.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-arc.x\">x</a> and <a href=\"#graphic.elements-arc.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-arc.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-arc.scaleX\">scaleX</a> and <a href=\"#graphic.elements-arc.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-arc.originX\">originX</a> and <a href=\"#graphic.elements-arc.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-arc.x\">x</a> and <a href=\"#graphic.elements-arc.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-arc.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-arc.scaleX\">scaleX</a> and <a href=\"#graphic.elements-arc.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-arc.originX\">originX</a> and <a href=\"#graphic.elements-arc.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-arc.x\">x</a> and <a href=\"#graphic.elements-arc.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-arc.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-arc.scaleX\">scaleX</a> and <a href=\"#graphic.elements-arc.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-arc.originX\">originX</a> and <a href=\"#graphic.elements-arc.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-arc.x\">x</a> and <a href=\"#graphic.elements-arc.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-arc.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-arc.scaleX\">scaleX</a> and <a href=\"#graphic.elements-arc.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-arc.originX\">originX</a> and <a href=\"#graphic.elements-arc.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"left":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-arc.left\">left</a> and <a href=\"#graphic.elements-arc.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-arc.left\">left</a> or <a href=\"#graphic.elements-arc.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-arc.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"right":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-arc.left\">left</a> and <a href=\"#graphic.elements-arc.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-arc.left\">left</a> or <a href=\"#graphic.elements-arc.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-arc.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"top":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-arc.top\">top</a> and <a href=\"#graphic.elements-arc.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-arc.top\">top</a> or <a href=\"#graphic.elements-arc.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-arc.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bottom":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-arc.top\">top</a> and <a href=\"#graphic.elements-arc.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-arc.top\">top</a> or <a href=\"#graphic.elements-arc.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-arc.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bounding":{"type":["string"],"description":"<p>Used to specify whether the entire transformed element (containing children if is group) is confined in its container.</p>\n<p>See sample:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/graphic-bounding&edit=1&reset=1\" width=\"500\" height=\"500\"></iframe>\n\n\n<p>Optional values:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;all&#39;</code>: (default)\n  Use the transformed bounding box of itself and its descendants to perform position calculation, which confine the entire body in the boundary of its parent.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;raw&#39;</code>:\n  Only use the untransformed bounding box of itself (without its descentant) to perform position calculation, which is suitable when the content in the element need to be overflow its parent.</p>\n</li>\n</ul>\n","default":"'all'"},"z":{"type":["number"],"description":"<p>z value of the elements, determine the overlap order.</p>\n","default":0},"zlevel":{"type":["number"],"description":"<p>Determine which canvas layer this element should be in.</p>\n<p>Notice: Multiple canvas layer may affect performance.</p>\n","default":0},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"draggable":{"type":["boolean"],"description":"<p>Can be dragged or not.</p>\n","default":false},"progressive":{"type":["boolean"],"description":"<p>Whether use progressive render to improve performance. Usually used when number of element is too large.</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"cx":{"type":["number"],"description":"<p>The x value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"cy":{"type":["numbr"],"description":"<p>The y value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"r":{"type":["number"],"description":"<p>Outside radius.</p>\n","default":0},"r0":{"type":["number"],"description":"<p>Inside radius.</p>\n","default":0},"startAngle":{"type":["number"],"description":"<p>start angle, in radian.</p>\n","default":0},"endAngle":{"type":["number"],"description":"<p>end angle, in radian.</p>\n","default":"Math.PI * 2"},"clockwise":{"type":["boolean"],"description":"<p>Whether draw clockwise.</p>\n","default":true}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":null},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":"\"#000\""},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":1},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"}}},"onclick":{"type":["Function"],"description":""},"onmouseover":{"type":["Function"],"description":""},"onmouseout":{"type":["Function"],"description":""},"onmousemove":{"type":["Function"],"description":""},"onmousewheel":{"type":["Function"],"description":""},"onmousedown":{"type":["Function"],"description":""},"onmouseup":{"type":["Function"],"description":""},"ondrag":{"type":["Function"],"description":""},"ondragstart":{"type":["Function"],"description":""},"ondragend":{"type":["Function"],"description":""},"ondragenter":{"type":["Function"],"description":""},"ondragleave":{"type":["Function"],"description":""},"ondragover":{"type":["Function"],"description":""},"ondrop":{"type":["Function"],"description":""}}},{"type":["Object"],"description":"<p>Polygon element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#graphic.elements-image\">image</a>,\n<a href=\"#graphic.elements-text\">text</a>,\n<a href=\"#graphic.elements-circle\">circle</a>,\n<a href=\"#graphic.elements-sector\">sector</a>,\n<a href=\"#graphic.elements-ring\">ring</a>,\n<a href=\"#graphic.elements-polygon\">polygon</a>,\n<a href=\"#graphic.elements-polyline\">polyline</a>,\n<a href=\"#graphic.elements-rect\">rect</a>,\n<a href=\"#graphic.elements-line\">line</a>,\n<a href=\"#graphic.elements-bezierCurve\">bezierCurve</a>,\n<a href=\"#graphic.elements-arc\">arc</a>,\n<a href=\"#graphic.elements-group\">group</a>,</p>\n","default":"polygon"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"$action":{"type":["string"],"description":"<p>Specify the operation should be performed to the element when calling <code class=\"codespan\">setOption</code>.\nDefault value is &#39;merge&#39;, other values can be &#39;replace&#39; or &#39;remove&#39;.</p>\n<p>Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;merge&#39;</code>: merge the given option to existing element (if any), otherwise create a new element.</li>\n<li><code class=\"codespan\">&#39;replace&#39;</code>: create a new element according to the given option and replace the existing element (if any).</li>\n<li><code class=\"codespan\">&#39;remove&#39;</code>: delete the existing element (if any).</li>\n</ul>\n","default":"'merge'"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-polygon.x\">x</a> and <a href=\"#graphic.elements-polygon.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-polygon.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-polygon.scaleX\">scaleX</a> and <a href=\"#graphic.elements-polygon.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-polygon.originX\">originX</a> and <a href=\"#graphic.elements-polygon.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-polygon.x\">x</a> and <a href=\"#graphic.elements-polygon.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-polygon.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-polygon.scaleX\">scaleX</a> and <a href=\"#graphic.elements-polygon.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-polygon.originX\">originX</a> and <a href=\"#graphic.elements-polygon.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-polygon.x\">x</a> and <a href=\"#graphic.elements-polygon.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-polygon.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-polygon.scaleX\">scaleX</a> and <a href=\"#graphic.elements-polygon.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-polygon.originX\">originX</a> and <a href=\"#graphic.elements-polygon.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-polygon.x\">x</a> and <a href=\"#graphic.elements-polygon.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-polygon.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-polygon.scaleX\">scaleX</a> and <a href=\"#graphic.elements-polygon.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-polygon.originX\">originX</a> and <a href=\"#graphic.elements-polygon.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-polygon.x\">x</a> and <a href=\"#graphic.elements-polygon.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-polygon.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-polygon.scaleX\">scaleX</a> and <a href=\"#graphic.elements-polygon.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-polygon.originX\">originX</a> and <a href=\"#graphic.elements-polygon.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-polygon.x\">x</a> and <a href=\"#graphic.elements-polygon.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-polygon.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-polygon.scaleX\">scaleX</a> and <a href=\"#graphic.elements-polygon.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-polygon.originX\">originX</a> and <a href=\"#graphic.elements-polygon.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-polygon.x\">x</a> and <a href=\"#graphic.elements-polygon.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-polygon.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-polygon.scaleX\">scaleX</a> and <a href=\"#graphic.elements-polygon.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-polygon.originX\">originX</a> and <a href=\"#graphic.elements-polygon.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"left":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-polygon.left\">left</a> and <a href=\"#graphic.elements-polygon.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-polygon.left\">left</a> or <a href=\"#graphic.elements-polygon.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-polygon.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"right":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-polygon.left\">left</a> and <a href=\"#graphic.elements-polygon.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-polygon.left\">left</a> or <a href=\"#graphic.elements-polygon.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-polygon.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"top":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-polygon.top\">top</a> and <a href=\"#graphic.elements-polygon.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-polygon.top\">top</a> or <a href=\"#graphic.elements-polygon.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-polygon.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bottom":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-polygon.top\">top</a> and <a href=\"#graphic.elements-polygon.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-polygon.top\">top</a> or <a href=\"#graphic.elements-polygon.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-polygon.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bounding":{"type":["string"],"description":"<p>Used to specify whether the entire transformed element (containing children if is group) is confined in its container.</p>\n<p>See sample:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/graphic-bounding&edit=1&reset=1\" width=\"500\" height=\"500\"></iframe>\n\n\n<p>Optional values:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;all&#39;</code>: (default)\n  Use the transformed bounding box of itself and its descendants to perform position calculation, which confine the entire body in the boundary of its parent.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;raw&#39;</code>:\n  Only use the untransformed bounding box of itself (without its descentant) to perform position calculation, which is suitable when the content in the element need to be overflow its parent.</p>\n</li>\n</ul>\n","default":"'all'"},"z":{"type":["number"],"description":"<p>z value of the elements, determine the overlap order.</p>\n","default":0},"zlevel":{"type":["number"],"description":"<p>Determine which canvas layer this element should be in.</p>\n<p>Notice: Multiple canvas layer may affect performance.</p>\n","default":0},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"draggable":{"type":["boolean"],"description":"<p>Can be dragged or not.</p>\n","default":false},"progressive":{"type":["boolean"],"description":"<p>Whether use progressive render to improve performance. Usually used when number of element is too large.</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"points":{"type":["Array"],"description":"<p>A list of points, which defines the shape, like <code class=\"codespan\">[[22, 44], [44, 55], [11, 44], ...]</code>.</p>\n"},"smooth":{"type":["number","string"],"description":"<p>Whether smooth the line.</p>\n<ul>\n<li>If the value is number, bezier interpolation is used, and the value specified the level of smooth, which is in the range of <code class=\"codespan\">[0, 1]</code>.</li>\n<li>If the value is <code class=\"codespan\">&#39;spline&#39;</code>, Catmull-Rom spline interpolation is used.</li>\n</ul>\n","default":"undefined"},"smoothConstraint":{"type":["boolean"],"description":"<p>Whether prevent the smooth process cause the line out of the bounding box.</p>\n<p>Only works when <code class=\"codespan\">smooth</code> is <code class=\"codespan\">number</code> (bezier smooth).</p>\n","default":false}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"}}},"onclick":{"type":["Function"],"description":""},"onmouseover":{"type":["Function"],"description":""},"onmouseout":{"type":["Function"],"description":""},"onmousemove":{"type":["Function"],"description":""},"onmousewheel":{"type":["Function"],"description":""},"onmousedown":{"type":["Function"],"description":""},"onmouseup":{"type":["Function"],"description":""},"ondrag":{"type":["Function"],"description":""},"ondragstart":{"type":["Function"],"description":""},"ondragend":{"type":["Function"],"description":""},"ondragenter":{"type":["Function"],"description":""},"ondragleave":{"type":["Function"],"description":""},"ondragover":{"type":["Function"],"description":""},"ondrop":{"type":["Function"],"description":""}}},{"type":["Object"],"description":"<p>Polyline element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#graphic.elements-image\">image</a>,\n<a href=\"#graphic.elements-text\">text</a>,\n<a href=\"#graphic.elements-circle\">circle</a>,\n<a href=\"#graphic.elements-sector\">sector</a>,\n<a href=\"#graphic.elements-ring\">ring</a>,\n<a href=\"#graphic.elements-polygon\">polygon</a>,\n<a href=\"#graphic.elements-polyline\">polyline</a>,\n<a href=\"#graphic.elements-rect\">rect</a>,\n<a href=\"#graphic.elements-line\">line</a>,\n<a href=\"#graphic.elements-bezierCurve\">bezierCurve</a>,\n<a href=\"#graphic.elements-arc\">arc</a>,\n<a href=\"#graphic.elements-group\">group</a>,</p>\n","default":"polyline"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"$action":{"type":["string"],"description":"<p>Specify the operation should be performed to the element when calling <code class=\"codespan\">setOption</code>.\nDefault value is &#39;merge&#39;, other values can be &#39;replace&#39; or &#39;remove&#39;.</p>\n<p>Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;merge&#39;</code>: merge the given option to existing element (if any), otherwise create a new element.</li>\n<li><code class=\"codespan\">&#39;replace&#39;</code>: create a new element according to the given option and replace the existing element (if any).</li>\n<li><code class=\"codespan\">&#39;remove&#39;</code>: delete the existing element (if any).</li>\n</ul>\n","default":"'merge'"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-polyline.x\">x</a> and <a href=\"#graphic.elements-polyline.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-polyline.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-polyline.scaleX\">scaleX</a> and <a href=\"#graphic.elements-polyline.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-polyline.originX\">originX</a> and <a href=\"#graphic.elements-polyline.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-polyline.x\">x</a> and <a href=\"#graphic.elements-polyline.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-polyline.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-polyline.scaleX\">scaleX</a> and <a href=\"#graphic.elements-polyline.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-polyline.originX\">originX</a> and <a href=\"#graphic.elements-polyline.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-polyline.x\">x</a> and <a href=\"#graphic.elements-polyline.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-polyline.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-polyline.scaleX\">scaleX</a> and <a href=\"#graphic.elements-polyline.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-polyline.originX\">originX</a> and <a href=\"#graphic.elements-polyline.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-polyline.x\">x</a> and <a href=\"#graphic.elements-polyline.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-polyline.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-polyline.scaleX\">scaleX</a> and <a href=\"#graphic.elements-polyline.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-polyline.originX\">originX</a> and <a href=\"#graphic.elements-polyline.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-polyline.x\">x</a> and <a href=\"#graphic.elements-polyline.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-polyline.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-polyline.scaleX\">scaleX</a> and <a href=\"#graphic.elements-polyline.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-polyline.originX\">originX</a> and <a href=\"#graphic.elements-polyline.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-polyline.x\">x</a> and <a href=\"#graphic.elements-polyline.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-polyline.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-polyline.scaleX\">scaleX</a> and <a href=\"#graphic.elements-polyline.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-polyline.originX\">originX</a> and <a href=\"#graphic.elements-polyline.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-polyline.x\">x</a> and <a href=\"#graphic.elements-polyline.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-polyline.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-polyline.scaleX\">scaleX</a> and <a href=\"#graphic.elements-polyline.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-polyline.originX\">originX</a> and <a href=\"#graphic.elements-polyline.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"left":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-polyline.left\">left</a> and <a href=\"#graphic.elements-polyline.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-polyline.left\">left</a> or <a href=\"#graphic.elements-polyline.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-polyline.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"right":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-polyline.left\">left</a> and <a href=\"#graphic.elements-polyline.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-polyline.left\">left</a> or <a href=\"#graphic.elements-polyline.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-polyline.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"top":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-polyline.top\">top</a> and <a href=\"#graphic.elements-polyline.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-polyline.top\">top</a> or <a href=\"#graphic.elements-polyline.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-polyline.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bottom":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-polyline.top\">top</a> and <a href=\"#graphic.elements-polyline.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-polyline.top\">top</a> or <a href=\"#graphic.elements-polyline.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-polyline.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bounding":{"type":["string"],"description":"<p>Used to specify whether the entire transformed element (containing children if is group) is confined in its container.</p>\n<p>See sample:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/graphic-bounding&edit=1&reset=1\" width=\"500\" height=\"500\"></iframe>\n\n\n<p>Optional values:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;all&#39;</code>: (default)\n  Use the transformed bounding box of itself and its descendants to perform position calculation, which confine the entire body in the boundary of its parent.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;raw&#39;</code>:\n  Only use the untransformed bounding box of itself (without its descentant) to perform position calculation, which is suitable when the content in the element need to be overflow its parent.</p>\n</li>\n</ul>\n","default":"'all'"},"z":{"type":["number"],"description":"<p>z value of the elements, determine the overlap order.</p>\n","default":0},"zlevel":{"type":["number"],"description":"<p>Determine which canvas layer this element should be in.</p>\n<p>Notice: Multiple canvas layer may affect performance.</p>\n","default":0},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"draggable":{"type":["boolean"],"description":"<p>Can be dragged or not.</p>\n","default":false},"progressive":{"type":["boolean"],"description":"<p>Whether use progressive render to improve performance. Usually used when number of element is too large.</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"points":{"type":["Array"],"description":"<p>A list of points, which defines the shape, like <code class=\"codespan\">[[22, 44], [44, 55], [11, 44], ...]</code>.</p>\n"},"smooth":{"type":["number","string"],"description":"<p>Whether smooth the line.</p>\n<ul>\n<li>If the value is number, bezier interpolation is used, and the value specified the level of smooth, which is in the range of <code class=\"codespan\">[0, 1]</code>.</li>\n<li>If the value is <code class=\"codespan\">&#39;spline&#39;</code>, Catmull-Rom spline interpolation is used.</li>\n</ul>\n","default":"undefined"},"smoothConstraint":{"type":["boolean"],"description":"<p>Whether prevent the smooth process cause the line out of the bounding box.</p>\n<p>Only works when <code class=\"codespan\">smooth</code> is <code class=\"codespan\">number</code> (bezier smooth).</p>\n","default":false}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":null},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":"\"#000\""},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":5},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"}}},"onclick":{"type":["Function"],"description":""},"onmouseover":{"type":["Function"],"description":""},"onmouseout":{"type":["Function"],"description":""},"onmousemove":{"type":["Function"],"description":""},"onmousewheel":{"type":["Function"],"description":""},"onmousedown":{"type":["Function"],"description":""},"onmouseup":{"type":["Function"],"description":""},"ondrag":{"type":["Function"],"description":""},"ondragstart":{"type":["Function"],"description":""},"ondragend":{"type":["Function"],"description":""},"ondragenter":{"type":["Function"],"description":""},"ondragleave":{"type":["Function"],"description":""},"ondragover":{"type":["Function"],"description":""},"ondrop":{"type":["Function"],"description":""}}},{"type":["Object"],"description":"<p>Line element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#graphic.elements-image\">image</a>,\n<a href=\"#graphic.elements-text\">text</a>,\n<a href=\"#graphic.elements-circle\">circle</a>,\n<a href=\"#graphic.elements-sector\">sector</a>,\n<a href=\"#graphic.elements-ring\">ring</a>,\n<a href=\"#graphic.elements-polygon\">polygon</a>,\n<a href=\"#graphic.elements-polyline\">polyline</a>,\n<a href=\"#graphic.elements-rect\">rect</a>,\n<a href=\"#graphic.elements-line\">line</a>,\n<a href=\"#graphic.elements-bezierCurve\">bezierCurve</a>,\n<a href=\"#graphic.elements-arc\">arc</a>,\n<a href=\"#graphic.elements-group\">group</a>,</p>\n","default":"line"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"$action":{"type":["string"],"description":"<p>Specify the operation should be performed to the element when calling <code class=\"codespan\">setOption</code>.\nDefault value is &#39;merge&#39;, other values can be &#39;replace&#39; or &#39;remove&#39;.</p>\n<p>Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;merge&#39;</code>: merge the given option to existing element (if any), otherwise create a new element.</li>\n<li><code class=\"codespan\">&#39;replace&#39;</code>: create a new element according to the given option and replace the existing element (if any).</li>\n<li><code class=\"codespan\">&#39;remove&#39;</code>: delete the existing element (if any).</li>\n</ul>\n","default":"'merge'"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-line.x\">x</a> and <a href=\"#graphic.elements-line.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-line.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-line.scaleX\">scaleX</a> and <a href=\"#graphic.elements-line.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-line.originX\">originX</a> and <a href=\"#graphic.elements-line.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-line.x\">x</a> and <a href=\"#graphic.elements-line.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-line.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-line.scaleX\">scaleX</a> and <a href=\"#graphic.elements-line.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-line.originX\">originX</a> and <a href=\"#graphic.elements-line.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-line.x\">x</a> and <a href=\"#graphic.elements-line.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-line.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-line.scaleX\">scaleX</a> and <a href=\"#graphic.elements-line.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-line.originX\">originX</a> and <a href=\"#graphic.elements-line.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-line.x\">x</a> and <a href=\"#graphic.elements-line.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-line.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-line.scaleX\">scaleX</a> and <a href=\"#graphic.elements-line.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-line.originX\">originX</a> and <a href=\"#graphic.elements-line.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-line.x\">x</a> and <a href=\"#graphic.elements-line.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-line.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-line.scaleX\">scaleX</a> and <a href=\"#graphic.elements-line.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-line.originX\">originX</a> and <a href=\"#graphic.elements-line.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-line.x\">x</a> and <a href=\"#graphic.elements-line.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-line.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-line.scaleX\">scaleX</a> and <a href=\"#graphic.elements-line.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-line.originX\">originX</a> and <a href=\"#graphic.elements-line.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-line.x\">x</a> and <a href=\"#graphic.elements-line.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-line.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-line.scaleX\">scaleX</a> and <a href=\"#graphic.elements-line.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-line.originX\">originX</a> and <a href=\"#graphic.elements-line.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"left":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-line.left\">left</a> and <a href=\"#graphic.elements-line.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-line.left\">left</a> or <a href=\"#graphic.elements-line.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-line.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"right":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-line.left\">left</a> and <a href=\"#graphic.elements-line.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-line.left\">left</a> or <a href=\"#graphic.elements-line.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-line.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"top":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-line.top\">top</a> and <a href=\"#graphic.elements-line.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-line.top\">top</a> or <a href=\"#graphic.elements-line.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-line.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bottom":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-line.top\">top</a> and <a href=\"#graphic.elements-line.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-line.top\">top</a> or <a href=\"#graphic.elements-line.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-line.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bounding":{"type":["string"],"description":"<p>Used to specify whether the entire transformed element (containing children if is group) is confined in its container.</p>\n<p>See sample:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/graphic-bounding&edit=1&reset=1\" width=\"500\" height=\"500\"></iframe>\n\n\n<p>Optional values:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;all&#39;</code>: (default)\n  Use the transformed bounding box of itself and its descendants to perform position calculation, which confine the entire body in the boundary of its parent.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;raw&#39;</code>:\n  Only use the untransformed bounding box of itself (without its descentant) to perform position calculation, which is suitable when the content in the element need to be overflow its parent.</p>\n</li>\n</ul>\n","default":"'all'"},"z":{"type":["number"],"description":"<p>z value of the elements, determine the overlap order.</p>\n","default":0},"zlevel":{"type":["number"],"description":"<p>Determine which canvas layer this element should be in.</p>\n<p>Notice: Multiple canvas layer may affect performance.</p>\n","default":0},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"draggable":{"type":["boolean"],"description":"<p>Can be dragged or not.</p>\n","default":false},"progressive":{"type":["boolean"],"description":"<p>Whether use progressive render to improve performance. Usually used when number of element is too large.</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"x1":{"type":["number"],"description":"<p>x value of the start point.</p>\n","default":0},"y1":{"type":["number"],"description":"<p>y value of the start point.</p>\n","default":0},"x2":{"type":["number"],"description":"<p>x value of the end point.</p>\n","default":0},"y2":{"type":["number"],"description":"<p>y value of the end point.</p>\n","default":0},"percent":{"type":["number"],"description":"<p>Specify the percentage of drawing, useful in animation.</p>\n<p>Value range: [0, 1].</p>\n","default":1}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":null},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":"\"#000\""},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":5},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"}}},"onclick":{"type":["Function"],"description":""},"onmouseover":{"type":["Function"],"description":""},"onmouseout":{"type":["Function"],"description":""},"onmousemove":{"type":["Function"],"description":""},"onmousewheel":{"type":["Function"],"description":""},"onmousedown":{"type":["Function"],"description":""},"onmouseup":{"type":["Function"],"description":""},"ondrag":{"type":["Function"],"description":""},"ondragstart":{"type":["Function"],"description":""},"ondragend":{"type":["Function"],"description":""},"ondragenter":{"type":["Function"],"description":""},"ondragleave":{"type":["Function"],"description":""},"ondragover":{"type":["Function"],"description":""},"ondrop":{"type":["Function"],"description":""}}},{"type":["Object"],"description":"<p>Quadratic bezier curve or cubic bezier curve.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#graphic.elements-image\">image</a>,\n<a href=\"#graphic.elements-text\">text</a>,\n<a href=\"#graphic.elements-circle\">circle</a>,\n<a href=\"#graphic.elements-sector\">sector</a>,\n<a href=\"#graphic.elements-ring\">ring</a>,\n<a href=\"#graphic.elements-polygon\">polygon</a>,\n<a href=\"#graphic.elements-polyline\">polyline</a>,\n<a href=\"#graphic.elements-rect\">rect</a>,\n<a href=\"#graphic.elements-line\">line</a>,\n<a href=\"#graphic.elements-bezierCurve\">bezierCurve</a>,\n<a href=\"#graphic.elements-arc\">arc</a>,\n<a href=\"#graphic.elements-group\">group</a>,</p>\n","default":"bezierCurve"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"$action":{"type":["string"],"description":"<p>Specify the operation should be performed to the element when calling <code class=\"codespan\">setOption</code>.\nDefault value is &#39;merge&#39;, other values can be &#39;replace&#39; or &#39;remove&#39;.</p>\n<p>Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;merge&#39;</code>: merge the given option to existing element (if any), otherwise create a new element.</li>\n<li><code class=\"codespan\">&#39;replace&#39;</code>: create a new element according to the given option and replace the existing element (if any).</li>\n<li><code class=\"codespan\">&#39;remove&#39;</code>: delete the existing element (if any).</li>\n</ul>\n","default":"'merge'"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-bezierCurve.x\">x</a> and <a href=\"#graphic.elements-bezierCurve.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-bezierCurve.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-bezierCurve.scaleX\">scaleX</a> and <a href=\"#graphic.elements-bezierCurve.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-bezierCurve.originX\">originX</a> and <a href=\"#graphic.elements-bezierCurve.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-bezierCurve.x\">x</a> and <a href=\"#graphic.elements-bezierCurve.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-bezierCurve.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-bezierCurve.scaleX\">scaleX</a> and <a href=\"#graphic.elements-bezierCurve.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-bezierCurve.originX\">originX</a> and <a href=\"#graphic.elements-bezierCurve.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-bezierCurve.x\">x</a> and <a href=\"#graphic.elements-bezierCurve.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-bezierCurve.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-bezierCurve.scaleX\">scaleX</a> and <a href=\"#graphic.elements-bezierCurve.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-bezierCurve.originX\">originX</a> and <a href=\"#graphic.elements-bezierCurve.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-bezierCurve.x\">x</a> and <a href=\"#graphic.elements-bezierCurve.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-bezierCurve.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-bezierCurve.scaleX\">scaleX</a> and <a href=\"#graphic.elements-bezierCurve.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-bezierCurve.originX\">originX</a> and <a href=\"#graphic.elements-bezierCurve.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-bezierCurve.x\">x</a> and <a href=\"#graphic.elements-bezierCurve.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-bezierCurve.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-bezierCurve.scaleX\">scaleX</a> and <a href=\"#graphic.elements-bezierCurve.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-bezierCurve.originX\">originX</a> and <a href=\"#graphic.elements-bezierCurve.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-bezierCurve.x\">x</a> and <a href=\"#graphic.elements-bezierCurve.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-bezierCurve.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-bezierCurve.scaleX\">scaleX</a> and <a href=\"#graphic.elements-bezierCurve.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-bezierCurve.originX\">originX</a> and <a href=\"#graphic.elements-bezierCurve.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#graphic.elements-bezierCurve.x\">x</a> and <a href=\"#graphic.elements-bezierCurve.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#graphic.elements-bezierCurve.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#graphic.elements-bezierCurve.scaleX\">scaleX</a> and <a href=\"#graphic.elements-bezierCurve.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#graphic.elements-bezierCurve.originX\">originX</a> and <a href=\"#graphic.elements-bezierCurve.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#graphic.elements-group\">group</a> or the root canvas). Thus we are able to <a href=\"#graphic.elements-group\">group</a> multiple elements, and <a href=\"#graphic.elements-group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"left":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-bezierCurve.left\">left</a> and <a href=\"#graphic.elements-bezierCurve.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-bezierCurve.left\">left</a> or <a href=\"#graphic.elements-bezierCurve.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-bezierCurve.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"right":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the height of its parent.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-bezierCurve.left\">left</a> and <a href=\"#graphic.elements-bezierCurve.right\">right</a> can work.</p>\n<p>If <a href=\"#graphic.elements-bezierCurve.left\">left</a> or <a href=\"#graphic.elements-bezierCurve.right\">right</a> is specified, positioning attributes in <a href=\"#graphic.elements-bezierCurve.shape\">shape</a> (like <code class=\"codespan\">x</code>, <code class=\"codespan\">cx</code>) will not work.</p>\n","default":"undefined"},"top":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-bezierCurve.top\">top</a> and <a href=\"#graphic.elements-bezierCurve.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-bezierCurve.top\">top</a> or <a href=\"#graphic.elements-bezierCurve.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-bezierCurve.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bottom":{"type":["number","string"],"description":"<p>Specify how to be positioned in its parent.</p>\n<p>When the element is at the top level, the parent is the container of the chart instance.\nOtherwise, the parent is a <code class=\"codespan\">group</code> element.</p>\n<p>Optional values:</p>\n<ul>\n<li>Pixel value: For example, can be a number <code class=\"codespan\">30</code>, means <code class=\"codespan\">30px</code>.</li>\n<li>Percent value: For example, can be a string <code class=\"codespan\">&#39;33%&#39;</code>, means the final result should be calculated by this value and the width of its parent.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code>: means position the element in the middle of according to its parent.</li>\n</ul>\n<p>Only one between <a href=\"#graphic.elements-bezierCurve.top\">top</a> and <a href=\"#graphic.elements-bezierCurve.bottom\">bottom</a> can work.</p>\n<p>If <a href=\"#graphic.elements-bezierCurve.top\">top</a> or <a href=\"#graphic.elements-bezierCurve.bottom\">bottom</a> is specified, positioning attributes in <a href=\"#graphic.elements-bezierCurve.shape\">shape</a> (like <code class=\"codespan\">y</code>, <code class=\"codespan\">cy</code>) will not work.</p>\n","default":"undefined"},"bounding":{"type":["string"],"description":"<p>Used to specify whether the entire transformed element (containing children if is group) is confined in its container.</p>\n<p>See sample:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/graphic-bounding&edit=1&reset=1\" width=\"500\" height=\"500\"></iframe>\n\n\n<p>Optional values:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;all&#39;</code>: (default)\n  Use the transformed bounding box of itself and its descendants to perform position calculation, which confine the entire body in the boundary of its parent.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;raw&#39;</code>:\n  Only use the untransformed bounding box of itself (without its descentant) to perform position calculation, which is suitable when the content in the element need to be overflow its parent.</p>\n</li>\n</ul>\n","default":"'all'"},"z":{"type":["number"],"description":"<p>z value of the elements, determine the overlap order.</p>\n","default":0},"zlevel":{"type":["number"],"description":"<p>Determine which canvas layer this element should be in.</p>\n<p>Notice: Multiple canvas layer may affect performance.</p>\n","default":0},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"draggable":{"type":["boolean"],"description":"<p>Can be dragged or not.</p>\n","default":false},"progressive":{"type":["boolean"],"description":"<p>Whether use progressive render to improve performance. Usually used when number of element is too large.</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"x1":{"type":["number"],"description":"<p>x value of the start point.</p>\n","default":0},"y1":{"type":["number"],"description":"<p>y value of the start point.</p>\n","default":0},"x2":{"type":["number"],"description":"<p>x value of the end point.</p>\n","default":0},"y2":{"type":["number"],"description":"<p>y value of the end point.</p>\n","default":0},"cpx1":{"type":["number"],"description":"<p>x of control point.</p>\n","default":0},"cpy1":{"type":["number"],"description":"<p>y of control point.</p>\n","default":0},"cpx2":{"type":["number"],"description":"<p>x of the second control point. If specified, cubic bezier is used.</p>\n<p>If both <code class=\"codespan\">cpx2</code> and <code class=\"codespan\">cpy2</code> are not set, quatratic bezier is used.</p>\n","default":null},"cpy2":{"type":["number"],"description":"<p>y of the second control point. If specified, cubic bezier is used.</p>\n<p>If both <code class=\"codespan\">cpx2</code> and <code class=\"codespan\">cpy2</code> are not set, quatratic bezier is used.</p>\n","default":null},"percent":{"type":["number"],"description":"<p>Specify the percentage of drawing, useful in animation.</p>\n<p>Value range: [0, 1].</p>\n","default":1}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"}}},"onclick":{"type":["Function"],"description":""},"onmouseover":{"type":["Function"],"description":""},"onmouseout":{"type":["Function"],"description":""},"onmousemove":{"type":["Function"],"description":""},"onmousewheel":{"type":["Function"],"description":""},"onmousedown":{"type":["Function"],"description":""},"onmouseup":{"type":["Function"],"description":""},"ondrag":{"type":["Function"],"description":""},"ondragstart":{"type":["Function"],"description":""},"ondragend":{"type":["Function"],"description":""},"ondragenter":{"type":["Function"],"description":""},"ondragleave":{"type":["Function"],"description":""},"ondragover":{"type":["Function"],"description":""},"ondrop":{"type":["Function"],"description":""}}}]},"description":"<p>A list of all graphic elements.</p>\n<p>Note, the standard configuration of graphic component is:</p>\n<pre><code class=\"lang-javascript\">{\n    graphic: {\n        elements: [\n            {type: &#39;rect&#39;, ...}, {type: &#39;circle&#39;, ...}, ...\n        ]\n    }\n}\n</code></pre>\n<p>But we always use short patterns for convenience:</p>\n<pre><code class=\"lang-javascript\">{\n    graphic: { // Declare only one graphic element.\n        type: &#39;rect&#39;,\n        ...\n    }\n}\n</code></pre>\n<p>Or:</p>\n<pre><code class=\"lang-javascript\">{\n    graphic: [ // Declare multiple graphic elements.\n        {type: &#39;rect&#39;, ...}, {type: &#39;circle&#39;, ...}, ...\n    ]\n}\n</code></pre>\n"}}},"calendar":{"type":["Object"],"description":"<p>Calendar coordinates.</p>\n<p>In ECharts, we are very creative to achieve the calendar chart, by using the calendar coordinates to achieve the calendar chart,\nas shown in the following example, we can use calendar coordinates in heatmap, scatter, effectScatter, and graph.</p>\n<p>Example of using heatmap in calendar coordinates:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=calendar-heatmap&edit=1&reset=1\" width=\"800\" height=\"400\"></iframe>\n\n\n<p>Example of using effectScatter in calendar coordinates:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=calendar-effectscatter&edit=1&reset=1\" width=\"800\" height=\"600\"></iframe>\n\n\n<p>Example of using graph in calendar coordinates:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=calendar-graph&edit=1&reset=1\" width=\"600\" height=\"600\"></iframe>\n\n\n<p>By combining calendar coordinate system and charts, you may be able to create more wonderful effects.</p>\n<p><a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=calendar-lunar&amp;edit=1&amp;reset=1\" target=\"_blank\">Display Text in Calendar</a>,\n<a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=calendar-pie&amp;edit=1&amp;reset=1\" target=\"_blank\">Display Pies in Calendar</a></p>\n<hr>\n<p><strong>Calendar layout</strong></p>\n<p>Calendar coordinate system can be placed horizontally or vertically. By convention, the heatmap calendar is horizontal. But if we need bigger cell size in other cases, the total width may be too wide. So <a href=\"#calendar.orient\">calendar.orient</a> can help in this case.</p>\n<hr>\n<p><strong>Adapt to container size</strong></p>\n<p>Calendar coordinate system can be configured to adapt to container size, which is useful when page size is not sure. First of all, like other components, those location and size configurations can be specified on canlendar: <a href=\"#calendar.left\">left</a> <a href=\"#calendar.right\">right</a> <a href=\"#calendar.top\">top</a> <a href=\"bottom\" target=\"_blank\">bottom</a> <a href=\"#calendar.width\">width</a> <a href=\"#calendar.height\">height</a>, which make calendar possible to modify its size according to container size. Besides, <a href=\"#calendar.cellSize\">cellSize</a> can be specified to fix the size of each cell of calendar.</p>\n<hr>\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between calendar component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":80},"top":{"type":["string","number"],"description":"<p>Distance between calendar component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":60},"right":{"type":["string","number"],"description":"<p>Distance between calendar component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"bottom":{"type":["string","number"],"description":"<p>Distance between calendar component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"width":{"type":["number","string"],"description":"\n\n<p>The height of calendar coordinates.</p>\n<p>Note: <code class=\"codespan\">cellSize</code> is 20 by default. If <code class=\"codespan\">width</code> is set,\n  <code class=\"codespan\">cellSize[0]</code> will be forced to <code class=\"codespan\">auto</code>;</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"auto"},"height":{"type":["number","string"],"description":"\n\n<p>The height of calendar coordinates.</p>\n<p>Note: <code class=\"codespan\">cellSize</code> is 20 by default. If <code class=\"codespan\">height</code> is set,\n  <code class=\"codespan\">cellSize[1]</code> will be forced to <code class=\"codespan\">auto</code>;</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":"auto"},"range":{"type":["number","string","Array"],"description":"<p>Required, range of Calendar coordinates, support multiple formats.</p>\n<p>Examples:</p>\n<pre><code class=\"lang-js\">\n// one year\nrange: 2017\n\n// one month\nrange: &#39;2017-02&#39;\n\n//  a range\nrange: [&#39;2017-01-02&#39;, &#39;2017-02-23&#39;]\n\n// note: they will be identified as [&#39;2017-01-01&#39;, &#39;2017-02-01&#39;]\nrange: [&#39;2017-01&#39;, &#39;2017-02&#39;]\n\n</code></pre>\n"},"cellSize":{"type":["number","Array"],"description":"\n\n<p>The size of each rect of calendar coordinates, can be set to a single value or array, the first element is width and the second element is height.</p>\n<p>Support setting self-adaptation: <code class=\"codespan\">auto</code>, the default width and height to be 20.</p>\n<p>Examples:</p>\n<pre><code class=\"lang-js\">\n// Set the width and height to be 20\ncellSize: 20\n\n// Set the width to be 20, and height to be 40\ncellSize: [20, 40]\n\n// Set width and height to be self-adaptation\ncellSize: [40]\n\n// Set the width and height to be 20\ncellSize: &#39;auto&#39;\n\n// Set the width to be self-adaptation, and height to be 40\ncellSize: [&#39;auto&#39;, 40]\n\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"20"},"default":20},"orient":{"type":["string"],"description":"\n\n<p>The layout orientation of calendar.</p>\n<p>Options:</p>\n<ul>\n<li>&#39;horizontal&#39;</li>\n<li>&#39;vertical&#39;</li>\n</ul>\n","uiControl":{"type":"enum","options":"horizontal,vertical","default":"horizontal"},"default":"'horizontal'"},"splitLine":{"type":["Object"],"description":"<p>Calendar coordinates splitLine style.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent the splitLine from showing</p>\n","uiControl":{"type":"boolean","show":"true"},"default":true},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>splitLineLine color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#000"},"width":{"type":["number"],"description":"\n\n<p>splitLine line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p>splitLine line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n<p>Examples:</p>\n<pre><code class=\"lang-js\">calendar: [{\n    splitLine: {\n        show: true,\n        lineStyle: {\n            color: &#39;#000&#39;,\n            width: 1,\n            type: &#39;solid&#39;\n        }\n    }\n}]\n</code></pre>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Every rect style in calendar coordinates.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>calendar color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#fff"},"borderColor":{"type":["Color"],"description":"\n\n<p>calendar border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#ccc'"},"borderWidth":{"type":["number"],"description":"\n\n<p>calendar border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n<p>Examples:</p>\n<pre><code class=\"lang-js\">calendar: [{\n    itemStyle: {\n        color: &#39;#fff&#39;,\n        borderWidth: 1,\n        borderColor: &#39;#ccc&#39;\n    }\n}]\n</code></pre>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"dayLabel":{"type":["Object"],"description":"<p>Day style in calendar coordinates.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent dayLabel from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"firstDay":{"type":["number"],"description":"\n\n<p>A week from the beginning of the week, the default starting on Sunday.</p>\n<p>Examples:</p>\n<pre><code class=\"lang-js\">\ncalendar: [{\n    dayLabel: {\n        firstDay: 1 // start on Monday\n    }\n}]\n\n</code></pre>\n","uiControl":{"type":"number","min":"0","max":"6","step":"1"},"default":0},"margin":{"type":["number"],"description":"\n\n<p>The margin between the day label and the axis line.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":0},"position":{"type":["string"],"description":"\n\n<p>Position of week, at the beginning or end of the range.</p>\n<p>Options:</p>\n<ul>\n<li>&#39;start&#39;</li>\n<li>&#39;end&#39;</li>\n</ul>\n","uiControl":{"type":"enum","options":"start,end","default":"start"},"default":"'start'"},"nameMap":{"type":["string","Array"],"description":"\n\n<p>Week text content, defaults to &#39;en&#39;;\nIt supports Chinese, English, and custom;\nindex 0 always means Sunday;</p>\n<p>Examples:</p>\n<pre><code class=\"lang-js\">\n// shortcut to English  [&#39;S&#39;, &#39;M&#39;, &#39;T&#39;, &#39;W&#39;, &#39;T&#39;, &#39;F&#39;, &#39;S&#39;],\nnameMap: &#39;en&#39;\n\n// shortcut to Chinese [&#39;日&#39;, &#39;一&#39;, &#39;二&#39;, &#39;三&#39;, &#39;四&#39;, &#39;五&#39;, &#39;六&#39;]\nnameMap: &#39;cn&#39;\n\n// Custom settings: mixed in English and Chinese or not displayed\nnameMap: [&#39;S&#39;, &#39;一&#39;, &#39;T&#39;, &#39;三&#39;, &#39;&#39;, &#39;五&#39;, &#39;S&#39;],\n\ncalendar: [{\n    dayLabel: {\n        nameMap: &#39;en&#39;\n    }\n}]\n</code></pre>\n","uiControl":{"type":"enum","options":"en,cn","default":"en"},"default":"'en'"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"#000"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"monthLabel":{"type":["Object"],"description":"<p>Month label in calendar coordinates.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to prevent monthLabel from showing.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"margin":{"type":["number"],"description":"\n\n<p>The margin between the month label and the axis line.</p>\n","uiControl":{"type":"number","min":"0","step":"5"},"default":5},"position":{"type":["string"],"description":"\n\n<p>Position of week, at the beginning or end of the range.</p>\n<p>Options:</p>\n<ul>\n<li>&#39;start&#39;</li>\n<li>&#39;end&#39;</li>\n</ul>\n","uiControl":{"type":"enum","options":"start,end","default":"start"},"default":"'start'"},"nameMap":{"type":["string","Array"],"description":"\n\n<p>Month text content, defaults to &#39;en&#39;;\nIt supports Chinese, English, and custom;\nIndex 0 always means Jan;</p>\n<p>Examples:</p>\n<pre><code class=\"lang-js\">// Shortcut to English [\n                &#39;Jan&#39;, &#39;Feb&#39;, &#39;Mar&#39;,\n                &#39;Apr&#39;, &#39;May&#39;, &#39;Jun&#39;,\n                &#39;Jul&#39;, &#39;Aug&#39;, &#39;Sep&#39;,\n                &#39;Oct&#39;, &#39;Nov&#39;, &#39;Dec&#39;\n            ],\nnameMap: &#39;en&#39;\n\n// Shortcut to Chinese [\n                &#39;一月&#39;, &#39;二月&#39;, &#39;三月&#39;,\n                &#39;四月&#39;, &#39;五月&#39;, &#39;六月&#39;,\n                &#39;七月&#39;, &#39;八月&#39;, &#39;九月&#39;,\n                &#39;十月&#39;, &#39;十一月&#39;, &#39;十二月&#39;\n            ]\nnameMap: &#39;cn&#39;\n\n// Custom settings: mixed in English and Chinese or not displayed\nnameMap: [\n            &#39;一月&#39;, &#39;Feb&#39;, &#39;三月&#39;,\n            &#39;四月&#39;, &#39;May&#39;, &#39;六月&#39;,\n            &#39;七月&#39;, &#39;八月&#39;, &#39;&#39;,\n            &#39;十月&#39;, &#39;Nov&#39;, &#39;十二月&#39;\n        ],\n\n\ncalendar: [{\n    monthLabel: {\n        nameMap: &#39;en&#39;\n    }\n}]\n</code></pre>\n","uiControl":{"type":"enum","options":"en,cn","default":"en"},"default":"'en'"},"formatter":{"type":["string","Function"],"description":"<p>Formatter of month text label, which supports string template and callback function.</p>\n<p>Examples:</p>\n<pre><code class=\"lang-js\">// Use string template; eg: 2017-02\n/*\n    template variables:\n    {nameMap} default nameMap eg：&#39;Feb&#39;\n    {yyyy}   four-digit years eg: 2017\n    {yy}   two-digit years eg: 17\n    {MM}   two-digit month eg: 02\n    {M}   single-digit month eg: 2\n*/\nformatter: &#39;{yyyy}-{MM}&#39;\n\n// Use callback function;\n/*\n    function parameters:\n    param.nameMap default nameMap eg：&#39;Feb&#39;\n    param.yyyy   four-digit years eg: 2017\n    param.yy   two-digit years eg: 17\n    param.MM   two-digit month eg: 02\n    param.M   single-digit eg: 2\n*/\nformatter: function (param) {\n    // ...\n    return param.MM;\n}\n</code></pre>\n","default":null},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"#000"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"yearLabel":{"type":["Object"],"description":"<p>Year label in calendar coordinates.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Set this to <code class=\"codespan\">false</code> to stop yearLabel from showing</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"margin":{"type":["number"],"description":"\n\n<p>The margin between the month label and the axis line.</p>\n","uiControl":{"type":"number","min":"0","step":"1"},"default":30},"position":{"type":["string"],"description":"\n\n<p>Position of year.</p>\n<p>Default:\nwhen orient is set as <code class=\"codespan\">horizontal</code>, position is <code class=\"codespan\">left</code>\nwhen orient is set as <code class=\"codespan\">vertical</code>, position is <code class=\"codespan\">top</code></p>\n<p>Options:</p>\n<ul>\n<li>&#39;top&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n</ul>\n","uiControl":{"type":"enum","options":"top,bottom,left,right"}},"formatter":{"type":["string","Function"],"description":"<p>Formatter of year text label, which supports string template and callback function.</p>\n<p>By default, the current range of the year, if the interval across the year, showing the first year and the last year</p>\n<p>Examples:</p>\n<pre><code class=\"lang-js\">// Use string template; eg: [&#39;2017-10-11&#39;, &#39;2018-01-21&#39;]\n/*\n    template variables:\n    {nameMap} default nameMap eg：&#39;2017-2018&#39;\n    {start}   start year eg: 2017\n    {end}   end year eg: 2018\n*/\n\nformatter: &#39;{start}-{end}&#39;\n\n// Use callback function;\n/*\n    function parameters:\n    param.nameMap default nameMap eg：&#39;2017-2018&#39;\n    param.start   start year eg: 2017\n    param.end   end year eg: 2018\n*/\nformatter: function (param) {\n    // ...\n    return param.end;\n}\n</code></pre>\n","default":null},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false}}},"dataset":{"type":["Object"],"description":"<p><code class=\"codespan\">dataset</code> component is published since ECharts 4. <code class=\"codespan\">dataset</code> brings convenience in data management separated with styles and enables data reuse by different series. More importantly, it enables data encoding from data to visual, which brings convenience in some scenarios.</p>\n<p>More details about <code class=\"codespan\">dataset</code> can be checked in the <a href=\"tutorial.html#Dataset\" target=\"_blank\">tutorial</a>.</p>\n","properties":{"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"source":{"type":["Array","Object"],"description":"<p>Source data. Generally speaking, a source data describe a table, where these format below can be applied:</p>\n<p>2d array, where <a href=\"#dataset.dimensions\">dimension names</a> can be provided in the first row/column, or do not provide, only data.</p>\n<pre><code class=\"lang-js\">[\n    [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n    [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n    [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n    [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n]\n</code></pre>\n<p>Row based key-value format (object array), where the keys indicate <a href=\"#dataset.dimensions\">dimension names</a>.</p>\n<pre><code class=\"lang-js\">[\n    {product: &#39;Matcha Latte&#39;, count: 823, score: 95.8},\n    {product: &#39;Milk Tea&#39;, count: 235, score: 81.4},\n    {product: &#39;Cheese Cocoa&#39;, count: 1042, score: 91.2},\n    {product: &#39;Walnut Brownie&#39;, count: 988, score: 76.9}\n]\n</code></pre>\n<p>Column based key-value format, where each value represents a column of a table.</p>\n<pre><code class=\"lang-js\">{\n    &#39;product&#39;: [&#39;Matcha Latte&#39;, &#39;Milk Tea&#39;, &#39;Cheese Cocoa&#39;, &#39;Walnut Brownie&#39;],\n    &#39;count&#39;: [823, 235, 1042, 988],\n    &#39;score&#39;: [95.8, 81.4, 91.2, 76.9]\n}\n</code></pre>\n<p>More details about <code class=\"codespan\">dataset</code> can be checked in the <a href=\"tutorial.html#dataset\" target=\"_blank\">tutorial</a>.</p>\n"},"dimensions":{"type":["Array"],"description":"<p><code class=\"codespan\">dimensions</code> can be used to define dimension info for <code class=\"codespan\">series.data</code> or <code class=\"codespan\">dataset.source</code>.</p>\n<p>Notice: if <a href=\"#dataset\">dataset</a> is used, we can definite dimensions in <a href=\"#dataset.dimensions\">dataset.dimensions</a>, or provide dimension names in the first column/row of <a href=\"#dataset.source\">dataset.source</a>, and not need to specify <code class=\"codespan\">dimensions</code> here. But if <code class=\"codespan\">dimensions</code> is specified here, it will be used despite the dimension definitions in dataset.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // &#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        // Specify name for each dimesions, which will be displayed in tooltip.\n        dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [\n        null,                // If you do not intent to defined this dimension, use null is fine.\n        {type: &#39;ordinal&#39;},   // Specify type of this dimension.\n                             // &#39;ordinal&#39; is always used in string.\n                             // If type is not specified, echarts will guess type by data.\n        {name: &#39;good&#39;, type: &#39;number&#39;},\n        &#39;bad&#39;                // Equals to {name: &#39;bad&#39;}.\n    ]\n}\n</code></pre>\n<p>Each data item of <code class=\"codespan\">dimensions</code> can be:</p>\n<ul>\n<li><code class=\"codespan\">string</code>, for example, <code class=\"codespan\">&#39;someName&#39;</code>, which equals to <code class=\"codespan\">{name: &#39;someName&#39;}</code>.</li>\n<li><code class=\"codespan\">Object</code>, where the attributes can be:<ul>\n<li>name: <code class=\"codespan\">string</code>.</li>\n<li>type: <code class=\"codespan\">string</code>, supports:<ul>\n<li><code class=\"codespan\">number</code></li>\n<li><code class=\"codespan\">float</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array\" target=\"_blank\">Float64Array</a></li>\n<li><code class=\"codespan\">int</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array\" target=\"_blank\">Int32Array</a></li>\n<li><code class=\"codespan\">ordinal</code>, discrete value, which represents string generally.</li>\n<li><code class=\"codespan\">time</code>, time value, see <a href=\"#series.data\">data</a> to check the format of time value.</li>\n</ul>\n</li>\n<li>displayName: <code class=\"codespan\">string</code>, generally used in tooltip for dimension display. If not specified, use <code class=\"codespan\">name</code> by default.</li>\n</ul>\n</li>\n</ul>\n<p>When <code class=\"codespan\">dimensions</code> is specified, the default <code class=\"codespan\">tooltip</code> will be displayed vertically, which is better to show diemsion names. Otherwise, <code class=\"codespan\">tooltip</code> will displayed only value horizontally.</p>\n"},"sourceHeader":{"type":["boolean"],"description":"<p>Whether the first row/column of <code class=\"codespan\">dataset.source</code> represents <a href=\"dataset.dimensions\" target=\"_blank\">dimension names</a>. Optional values:</p>\n<ul>\n<li><code class=\"codespan\">null/undefine</code>: means auto detect whether the first row/column is dimension names or data.</li>\n<li><code class=\"codespan\">true</code>: the first row/column is dimension names.</li>\n<li><code class=\"codespan\">false</code>: data start from the first row/column.</li>\n</ul>\n<p>Note: &quot;the first row/column&quot; means that if <a href=\"#series.seriesLayoutBy\">series.seriesLayoutBy</a> is set as <code class=\"codespan\">&#39;column&#39;</code>, pick the first row, otherwise, if it is set as <code class=\"codespan\">&#39;row&#39;</code>, pick the first column.</p>\n"},"transform":{"type":"Array","items":{"anyOf":[{"type":["Object"],"description":"","properties":{"type":{"type":["string"],"description":"","default":"'filter'"},"config":{"type":["*"],"description":"<p>The condition of transform &quot;filter&quot;.</p>\n<p>See the tutorial of <a href=\"tutorial.html#Data%20Transform\" target=\"_blank\">data transform</a>.</p>\n"},"print":{"type":["boolean"],"description":"<p>When using data transform, we might run into the trouble that the final chart do not display correctly but we do not know where the config is wrong. There is a property <code class=\"codespan\">transform.print</code> might help in such case. (<code class=\"codespan\">transform.print</code> is only available in dev environment).</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: [{\n        source: [ ... ]\n    }, {\n        transform: {\n            type: &#39;filter&#39;,\n            config: { ... }\n            // The result of this transform will be printed\n            // in dev tool via `console.log`.\n            print: true\n        }\n    }],\n    ...\n}\n</code></pre>\n","default":false}}},{"type":["Object"],"description":"","properties":{"type":{"type":["string"],"description":"","default":"'sort'"},"config":{"type":["*"],"description":"<p>The condition of transform &quot;sort&quot;.</p>\n<p>See the tutorial of <a href=\"tutorial.html#Data%20Transform\" target=\"_blank\">data transform</a>.</p>\n"},"print":{"type":["boolean"],"description":"<p>When using data transform, we might run into the trouble that the final chart do not display correctly but we do not know where the config is wrong. There is a property <code class=\"codespan\">transform.print</code> might help in such case. (<code class=\"codespan\">transform.print</code> is only available in dev environment).</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: [{\n        source: [ ... ]\n    }, {\n        transform: {\n            type: &#39;filter&#39;,\n            config: { ... }\n            // The result of this transform will be printed\n            // in dev tool via `console.log`.\n            print: true\n        }\n    }],\n    ...\n}\n</code></pre>\n","default":false}}},{"type":["Object"],"description":"<p>Besides built-in transforms (like &#39;filter&#39;, &#39;sort&#39;), we can also use external transforms to provide more powerful functionalities.</p>\n<p>See the tutorial of <a href=\"tutorial.html#Data%20Transform\" target=\"_blank\">data transform</a>.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Built-in transform has no namespace (like <code class=\"codespan\">type: &#39;filter&#39;</code>, <code class=\"codespan\">type: &#39;sort&#39;</code>).</p>\n<p>External transform has namespace (like <code class=\"codespan\">type: &#39;ecStat:regression&#39;</code>).</p>\n","default":"'xxx:xxx'"},"config":{"type":["*"],"description":"<p>The needed parameters of this data transform. Each type of transform has its own definition of <code class=\"codespan\">config</code>.</p>\n"},"print":{"type":["boolean"],"description":"<p>When using data transform, we might run into the trouble that the final chart do not display correctly but we do not know where the config is wrong. There is a property <code class=\"codespan\">transform.print</code> might help in such case. (<code class=\"codespan\">transform.print</code> is only available in dev environment).</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: [{\n        source: [ ... ]\n    }, {\n        transform: {\n            type: &#39;filter&#39;,\n            config: { ... }\n            // The result of this transform will be printed\n            // in dev tool via `console.log`.\n            print: true\n        }\n    }],\n    ...\n}\n</code></pre>\n","default":false}}}]},"description":"<p>See the tutorial of <a href=\"tutorial.html#Data%20Transform\" target=\"_blank\">data transform</a>.</p>\n"},"fromDatasetIndex":{"type":["number"],"description":"<p>Specify the input dataset for <a href=\"#dataset.transform\">dataset.transform</a>.\nIf <a href=\"#dataset.transform\">dataset.transform</a> specified but both <code class=\"codespan\">fromDatasetIndex</code> and <code class=\"codespan\">fromDatasetId</code> are not specified, <code class=\"codespan\">fromDatasetIndex: 0</code> will be used by default.</p>\n<p>See the tutorial of <a href=\"tutorial.html#Data%20Transform\" target=\"_blank\">data transform</a>.</p>\n"},"fromDatasetId":{"type":["string"],"description":"<p>Specify the input dataset for <a href=\"#dataset.transform\">dataset.transform</a>.</p>\n<p>See the tutorial of <a href=\"tutorial.html#Data%20Transform\" target=\"_blank\">data transform</a>.</p>\n"},"fromTransformResult":{"type":["number"],"description":"<p>If a <a href=\"#dataset.transform\">dataset.transform</a> produces more than one result, we can use <code class=\"codespan\">fromTransformResult</code> to retrieve some certain result.</p>\n<p>In most cases, <code class=\"codespan\">fromTransformResult</code> do not need to be specified because most transforms only produce one result. If <code class=\"codespan\">fromTransformResult</code> is not specified, we use <code class=\"codespan\">fromTransformResult: 0</code> by default.</p>\n<p>See the tutorial of <a href=\"tutorial.html#Data%20Transform\" target=\"_blank\">data transform</a>.</p>\n"}}},"aria":{"type":["*"],"description":"<p>The W3C has developed the <a href=\"https://www.w3.org/WAI/intro/aria\" target=\"_blank\">WAI-ARIA</a>, the Accessible Rich Internet Applications Suite, which is dedicated to making web content and web applications accessible. Apache ECharts 4 complies with this specification by supporting the automatic generation of intelligent descriptions based on chart configuration items, allowing blind people to understand the chart content with the help of a reading device, making the chart accessible to a wider audience. In addition, Apache ECharts 5 adds support for applique textures as an auxiliary expression of color to further differentiate the data.</p>\n<p>It is turned off by default and needs to be turned on by setting <a href=\"#aria.enabled\">aria.enabled</a> to <code class=\"codespan\">true</code>.</p>\n","properties":{"enabled":{"type":["boolean"],"description":"<p>Whether or not aria is turned on. If not, the <code class=\"codespan\">label</code> or <code class=\"codespan\">decal</code> effect is not applied.</p>\n","default":false},"label":{"type":["Object"],"description":"<p>If <a href=\"#aria.enabled\">aria.enabled</a> is set to <code class=\"codespan\">true</code>, <code class=\"codespan\">label</code> is enabled by default. When enabled, the description of the chart will be automatically and intelligently generated based on the chart, data, title, etc. Users can also modify the description through the configuration item.</p>\n<p><strong>Example:</strong></p>\n<pre><code class=\"lang-js\">option = {\n    aria: {\n        // The following lines can be omitted because label.enabled defaults to true.\n        // label: {\n        // enabled: true\n        // },\n        enabled: true\n    },\n    title: {\n        text: &#39;User access sources for a site&#39;,\n        x: &#39;center&#39;\n    },\n    series: [\n        {\n            name: &#39;access source&#39;,\n            type: &#39;pie&#39;,\n            data: [\n                { value: 335, name: &#39;Direct Access&#39; },\n                { value: 310, name: &#39;Email Marketing&#39; },\n                { value: 234, name: &#39;Affiliate Ads&#39; },\n                { value: 135, name: &#39;Video Ads&#39; },\n                { value: 1548, name: &#39;Search Engine&#39; }\n            ]\n        }\n    ]\n};\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-pie&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n\n<p>On the generated chart DOM, there is an <code class=\"codespan\">aria-label</code> attribute that allows the blind to understand the chart with the help of a reading device. Its value is.</p>\n<blockquote>\n<p>This is a chart of &quot;Source of user access to a site.&quot; The chart type is a pie chart that indicates the source of the visit. The data is - direct access data is 335, mail marketing data is 310, union ad data is 234, video ad data is 135, search engine data is 1548.</p>\n</blockquote>\n<p>The basic process for generating the description is that if <a href=\"#aria.enabled\">aria.enabled</a> is set to <code class=\"codespan\">true</code> (not the default) and <a href=\"#aria.label.enabled\">aria.label.enabled</a> is set to <code class=\"codespan\">true</code> (the default), then the accessibility description is generated. Otherwise it is not generated. If <a href=\"#aria.label.description\">aria.label.description</a> is defined, it is used as the full description of the chart, otherwise the description is generated according to the template stitching. We provide a default algorithm for generating descriptions, and only if the generated descriptions are not quite right, you need to modify these templates, or even override them completely with <code class=\"codespan\">aria.label.description</code>.</p>\n<p>When using the template, whether <a href=\"#title.text\">title.text</a> is used along with <a href=\"option.html#aria.label.general.withTitle\" target=\"_blank\">aria.label.general.withTitle</a> while <a href=\"option.html#aria.label.general.withoutTitle\" target=\"_blank\">aria.label.general.withoutTitle</a> is used if there is no title text. <code class=\"codespan\">aria.general.withTitle</code> supports a template <code class=\"codespan\">&#39;{title}&#39;</code>, which will be replaced with chart title. This means, if <code class=\"codespan\">aria.general.withTitle</code> is set to be <code class=\"codespan\">&#39;The chart title is {title}.&#39;</code> and the chart title is <code class=\"codespan\">Price Distribution</code>, it will be interpreted into <code class=\"codespan\">&#39;The chart title is Price Distribution.&#39;</code></p>\n<p>After generating the title, the description of the series (<a href=\"option.html#aria.label.series\" target=\"_blank\">aria.label.series</a>) and the description of the data for each series (<a href=\"option.html#aria.label.data\" target=\"_blank\">aria.label.data</a>) are generated in turn. The following is an example of a template. Likewise, each template may include template variables to replace actual values.</p>\n<p>The complete description generation process is:</p>\n<p><img width=\"800\" height=\"auto\" src=\"documents/asset/img/echarts-aria.jpg\"></p>\n","properties":{"enabled":{"type":["boolean"],"description":"<p>Whether or not to enable label generation for accessibility. When enabled, the attribute <code class=\"codespan\">aria-label</code> will be generated.</p>\n","default":true},"description":{"type":["string"],"description":"<p>By default, an algorithm is used to automatically generate a chart description, but if you want to fully customize it, you can set this value to a description. If it is set to <code class=\"codespan\">&#39;This is a chart showing price changes&#39;</code>, then the value of the <code class=\"codespan\">aria-label</code> attribute of the chart DOM is this string.</p>\n<p>This configuration item is often used to display text that specifies a general description of the chart, when displaying individual data does not show the contents of the chart. For example, if the chart is a map with a large number of scattered points, the default algorithm can only show the locations of the data points and cannot convey the author&#39;s intent as a whole. In this case, you can specify <code class=\"codespan\">description</code> as what the author wants to say.</p>\n","default":null},"general":{"type":["Object"],"description":"<p>For the overall description of the chart.</p>\n","properties":{"withTitle":{"type":["string"],"description":"<p>If the chart exists <a href=\"#title.text\">title.text</a>, then <code class=\"codespan\">withTitle</code> is used. This includes the template variable.</p>\n<ul>\n<li><code class=\"codespan\">{title}</code>: will be replaced with <a href=\"#title.text\">title.text</a> of the chart.</li>\n</ul>\n","default":"'This is a chart about \"{title}\".'"},"withoutTitle":{"type":["string"],"description":"<p>If the chart does not have <a href=\"#title.text\">title.text</a>, then <code class=\"codespan\">withoutTitle</code> is used.</p>\n","default":"'This is a chart,'"}}},"series":{"type":["Object"],"description":"<p>series-related configuration items.</p>\n","properties":{"maxCount":{"type":["number"],"description":"<p>The maximum number of series in the description.</p>\n","default":10},"single":{"type":["Object"],"description":"<p>The description used when the chart contains only one series.</p>\n","properties":{"prefix":{"type":["string"],"description":"<p>Holistic descriptions for all series are shown before each series description. This includes template variables.</p>\n<ul>\n<li><code class=\"codespan\">{seriesCount}</code>: will be replaced with the number of series, where it is always 1.</li>\n</ul>\n","default":"''"},"withName":{"type":["string"],"description":"<p>This description is used if the series has the <code class=\"codespan\">name</code> attribute. This includes the template variable.</p>\n<ul>\n<li><code class=\"codespan\">{seriesName}</code>: will be replaced with <code class=\"codespan\">name</code> of the series.</li>\n<li><code class=\"codespan\">{seriesType}</code>: the name of the type that will be replaced with the series, e.g. <code class=\"codespan\">&#39;Bar chart&#39;</code>, <code class=\"codespan\">&#39;Line chart&#39;</code>, etc.</li>\n</ul>\n","default":"' with type {seriesType} named {seriesName}.'"},"withoutName":{"type":["string"],"description":"<p>This description is used if the series has no <code class=\"codespan\">name</code> attribute. This includes the template variable.</p>\n<ul>\n<li><code class=\"codespan\">{seriesType}</code>: the name of the type that will be replaced with the series, e.g. <code class=\"codespan\">&#39;Bar chart&#39;</code>, <code class=\"codespan\">&#39;Line chart&#39;</code>, etc.</li>\n</ul>\n","default":"' with type {seriesType}.'"}}},"multiple":{"type":["Object"],"description":"<p>Description to use when the chart contains only multiple series.</p>\n","properties":{"prefix":{"type":["string"],"description":"<p>A holistic description for all series is displayed before each series description. This includes the template variable.</p>\n<ul>\n<li><code class=\"codespan\">{seriesCount}</code>: will be replaced with the number of series.</li>\n</ul>\n","default":"'. It consists of {seriesCount} series count.'"},"withName":{"type":["string"],"description":"<p>This description is used if the series has the <code class=\"codespan\">name</code> attribute. This includes the template variable.</p>\n<ul>\n<li><code class=\"codespan\">{seriesName}</code>: will be replaced with <code class=\"codespan\">name</code> of the series.</li>\n<li><code class=\"codespan\">{seriesType}</code>: the name of the type that will be replaced with the series, e.g. <code class=\"codespan\">&#39;Bar chart&#39;</code>, <code class=\"codespan\">&#39;Line chart&#39;</code>, etc.</li>\n</ul>\n","default":"' The {seriesId} series is a {seriesType} representing {seriesName}."},"withoutName":{"type":["string"],"description":"<p>This description is used if the series has no <code class=\"codespan\">name</code> attribute. This includes the template variable.</p>\n<ul>\n<li><code class=\"codespan\">{seriesType}</code>: the name of the type that will be replaced with the name of the series, e.g. <code class=\"codespan\">&#39;Bar chart&#39;</code>, <code class=\"codespan\">&#39;Line chart&#39;</code>, etc.</li>\n</ul>\n","default":"' The {seriesId} series is a {seriesType}.'"},"separator":{"type":["Object"],"description":"<p>The separator between the series and the description of the series.</p>\n","properties":{"middle":{"type":["string"],"description":"<p>Except for the separator after the last series.</p>\n","default":"';'"},"end":{"type":["string"],"description":"<p>Delimiter after the last series.</p>\n","default":"'.'"}}}}}}},"data":{"type":["Object"],"description":"<p>Data-related configuration items.</p>\n","properties":{"maxCount":{"type":["number"],"description":"<p>The maximum number of data occurrences per series in the description.</p>\n","default":10},"allData":{"type":["string"],"description":"<p>Description to be used when all data is displayed. This item <strong>doesn&#39;t</strong> make all the data displayed. It can be achieved by setting <a href=\"#aria.data.maxCount\">aria.data.maxCount</a> to <code class=\"codespan\">Number.MAX_VALUE</code>.</p>\n","default":"'whose data is --'"},"partialData":{"type":["string"],"description":"<p>Descriptions used when only partial data is displayed. This includes template variables.</p>\n<ul>\n<li><code class=\"codespan\">{displayCnt}</code>: the number of data that will be replaced with the number of displays.</li>\n</ul>\n","default":"'where the first {displayCnt} term is --'"},"withName":{"type":["string"],"description":"<p>This description is used if the data has the <code class=\"codespan\">name</code> attribute. This includes the template variable.</p>\n<ul>\n<li><code class=\"codespan\">{name}</code>: <code class=\"codespan\">name</code> that will be replaced with the data.</li>\n<li><code class=\"codespan\">{value}</code>: the value that will be replaced with the data.</li>\n</ul>\n","default":"'The data for {name} is {value}'"},"withoutName":{"type":["string"],"description":"<p>This description is used if the data does not have the <code class=\"codespan\">name</code> attribute. This includes the template variable.</p>\n<ul>\n<li><code class=\"codespan\">{value}</code>: the value that will be replaced with the data.</li>\n</ul>\n","default":"'{value}'"},"separator":{"type":["Object"],"description":"<p>The separator between data and data description.</p>\n","properties":{"middle":{"type":["string"],"description":"<p>The delimiter of the data except the last one.</p>\n","default":"','"},"end":{"type":["string"],"description":"<p>The delimiter after the last data.</p>\n<p>Note that usually the last series is followed by the series <code class=\"codespan\">separator.end</code>, so <code class=\"codespan\">data.separator.end</code> is an empty string in most cases.</p>\n","default":"''"}}}}}}},"decal":{"type":["Object"],"description":"<p>Decal patterns are added to series data as an additional hint other than colors to help differentiate the data. It is easy to enabled the default decal patterns by enabling it:</p>\n<pre><code>aria: {\n    enabled: true,\n    decal: {\n        show: true\n    }\n}\n</code></pre><iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal-simple&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n\n<p>Most series types are supported, including: <code class=\"codespan\">&#39;line&#39;</code>, <code class=\"codespan\">&#39;bar&#39;</code>, <code class=\"codespan\">&#39;pie&#39;</code>, <code class=\"codespan\">&#39;radar&#39;</code>, <code class=\"codespan\">&#39;treemap&#39;</code>, <code class=\"codespan\">&#39;sunburst&#39;</code>, <code class=\"codespan\">&#39;boxplot&#39;</code>, <code class=\"codespan\">&#39;sankey&#39;</code>, <code class=\"codespan\">&#39;funnel&#39;</code>, <code class=\"codespan\">&#39;gauge&#39;</code>, <code class=\"codespan\">&#39;pictorialBar&#39;</code>, <code class=\"codespan\">&#39;themeRiver&#39;</code>, <code class=\"codespan\">&#39;custom&#39;</code> and so on. Among them, some series have no filling color by default (such as <code class=\"codespan\">&#39;line&#39;</code>, <code class=\"codespan\">&#39;radar&#39;</code>, <code class=\"codespan\">&#39;boxplot&#39;</code>), which take effect only if the <code class=\"codespan\">&#39;areaStyle&#39;</code> is set.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether or not to display the decal pattern is not shown by default. If you want to display the applique, you need to make sure <a href=\"#aria.enabled\">aria.enabled</a> and <code class=\"codespan\">aria.decal.show</code> are both <code class=\"codespan\">true</code>.</p>\n","default":false},"decals":{"type":["Object","Array"],"description":"<p>The style of the decal pattern. If it is an <code class=\"codespan\">Object</code> type, it means all data will have the same style, if it is an array, then each item in the array will have one style and the data will be looped through the array in order.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}}}},"series":{"type":"Array","items":{"anyOf":[{"type":["Object"],"description":"<p><strong>broken line chart</strong></p>\n<p>Broken line chart relates all the data points <a href=\"#series-line.symbol\">symbol</a> by broken lines, which is used to show the trend of data changing. It could be used in both <a href=\"#grid\">rectangular coordinate</a> and<a href=\"#polar\">polar coordinate</a>.</p>\n<p><strong>Tip:</strong> When <a href=\"#series-line.areaStyle\">areaStyle</a> is set, area chart will be drew.</p>\n<p><strong>Tip:</strong> With <a href=\"#visualMap-piecewise\">visualMap</a> component, Broken line / area chart can have different colors on different sections, as below:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-aqi&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n","properties":{"type":{"type":["string"],"description":"","default":"'line'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"coordinateSystem":{"type":["string"],"description":"<p>The coordinate used in the series, whose options are:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;cartesian2d&#39;</code></p>\n<p>  Use a two-dimensional rectangular coordinate (also known as Cartesian coordinate), with <a href=\"#series-bar.xAxisIndex\">xAxisIndex</a> and <a href=\"#series-bar.yAxisIndex\">yAxisIndex</a> to assign the corresponding axis component.</p>\n</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;polar&#39;</code></p>\n<p>  Use polar coordinates, with <a href=\"#series-bar.polarIndex\">polarIndex</a> to assign the corresponding polar coordinate component.</p>\n</li>\n</ul>\n","default":"'cartesian2d'"},"xAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#xAxis\">x axis</a> to combine with, which is  useful for multiple x axes in one chart.</p>\n","default":0},"yAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#yAxis\">y axis</a> to combine with, which is  useful for multiple y axes in one chart.</p>\n","default":0},"polarIndex":{"type":["number"],"description":"<p>Index of <a href=\"#polar\">polar coordinate</a> to combine with, which is useful for multiple polar axes in one chart.</p>\n","default":0},"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-line.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'emptyCircle'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-line.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":4},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-line.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"showSymbol":{"type":["boolean"],"description":"\n\n<p>Whether to show symbol. It would be shown during tooltip hover.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"showAllSymbol":{"type":["boolean"],"description":"\n\n<p>Only work when main axis is <code class=\"codespan\">&#39;category&#39;</code> axis (<code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;category&#39;</code>). Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;auto&#39;</code>: Default value. Show all symbols if there is enough space. Otherwise follow the interval strategy with with <a href=\"#xAxis.axisLabel.interval\">axisLabel.interval</a>.</li>\n<li><code class=\"codespan\">true</code>: Show all symbols.</li>\n<li><code class=\"codespan\">false</code>: Follow the interval strategy with <a href=\"#xAxis.axisLabel.interval\">axisLabel.interval</a>.</li>\n</ul>\n","uiControl":{"type":"boolean"},"default":"'auto'"},"legendHoverLink":{"type":["boolean"],"description":"\n\n<p>Whether to enable highlighting chart when <a href=\"#legend\">legend</a> is being hovered.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"stack":{"type":["string"],"description":"<p>If stack the value. On the same category axis, the series with the same <code class=\"codespan\">stack</code> name would be put on top of each other.</p>\n<p>The effect of the below example could be seen through stack switching of <a href=\"#toolbox\">toolbox</a> on the top right corner:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/line-stack-tiled&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n\n","default":null},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"connectNulls":{"type":["boolean"],"description":"\n\n<p>Whether to connect the line across null points.</p>\n","uiControl":{"type":"boolean"},"default":false},"clip":{"type":["boolean"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v4.4.0</code></p>\n</blockquote>\n<p>If clip the overflow on the coordinate system. Clip results varies between series:</p>\n<ul>\n<li>Scatter：Ignore the symbols exceeds the coordinate system. Not clip the elements.</li>\n<li>Bar：Clip all the overflowed. With bar width kept.</li>\n<li>Line：Clip the overflowed line.</li>\n<li>Lines: Clip all the overflowed.</li>\n<li>Candlestick: Ignore the elements exceeds the coordinate system.</li>\n<li>Custom: Clip all the olverflowed.</li>\n</ul>\n<p>All these series have default value <code class=\"codespan\">true</code> except custom series. Set it to <code class=\"codespan\">false</code> if you don&#39;t want to clip.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"step":{"type":["string","boolean"],"description":"\n\n<p>Whether to show as a step line. It can be <code class=\"codespan\">true</code>, <code class=\"codespan\">false</code>. Or <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>. Which will configure the turn point of step line.</p>\n<p>See the example using different <code class=\"codespan\">step</code> options:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=line-step&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n","uiControl":{"type":"enum","options":"start,middle,end"},"default":false},"label":{"type":["Object"],"description":"<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'top'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"endLabel":{"type":["Object"],"description":"<p>Label on the end of line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}},"valueAnimation":{"type":["boolean"],"description":"<p>Whether to enable text animation of value change.</p>\n"}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"itemStyle":{"type":["Object"],"description":"<p>The style of the symbol point of broken line.</p>\n","properties":{"color":{"type":["Color","Function"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n<p>Supports callback functions, in the form of:</p>\n<pre><code class=\"lang-js\">(params: Object) =&gt; Color\n</code></pre>\n<p>Input parameters are <code class=\"codespan\">seriesIndex</code>, <code class=\"codespan\">dataIndex</code>, <code class=\"codespan\">data</code>, <code class=\"codespan\">value</code>, and etc. of data item.</p>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n<p>It works only if <code class=\"codespan\">areaStyle</code> is set.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"lineStyle":{"type":["Object"],"description":"<p>Line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"2","min":"0","step":"0.5"},"default":2},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"areaStyle":{"type":["Object"],"description":"<p>The style of area.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"origin":{"type":["string"],"description":"<p>Origin position of area.</p>\n<p>By default, the area between axis line and data will be the area to be filled. This config enables you to fill data to the max or min of the axis data.</p>\n<p>Valid values include: <code class=\"codespan\">&#39;auto&#39;</code> (default), <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>.</p>\n<ul>\n<li><code class=\"codespan\">&#39;auto&#39;</code> to fill between axis line to data;</li>\n<li><code class=\"codespan\">&#39;start&#39;</code> to fill between min axis value (when not <code class=\"codespan\">inverse</code>) to data;</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> to fill between max axis value (when not <code class=\"codespan\">inverse</code>) to data;</li>\n</ul>\n","default":"'auto'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Highlight style of the graphic.</p>\n","properties":{"scale":{"type":["boolean"],"description":"<p>Whether to scale to highlight the data in emphasis state.</p>\n","default":true},"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"2","min":"0","step":"0.5"},"default":2},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"areaStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"endLabel":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Available when <a href=\"#series-line.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"2","min":"0","step":"0.5"},"default":2},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"areaStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"endLabel":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of select state. Available when <a href=\"#series-line.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"2","min":"0","step":"0.5"},"default":2},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"areaStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"endLabel":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"smooth":{"type":["boolean","number"],"description":"<p>Whether to show as smooth curve.</p>\n<p>If is typed in <code class=\"codespan\">boolean</code>, then it means whether to enable smoothing. If is typed in <code class=\"codespan\">number</code>, valued from 0 to 1, then it means smoothness. A smaller value makes it less smooth.</p>\n<p>Please refer to <a href=\"#series-line.smoothMonotone\">smoothMonotone</a> to change smoothing algorithm.</p>\n","default":false},"smoothMonotone":{"type":["string"],"description":"<p>Whether the broken line keep the monotonicity when it is smoothed. It can be set as <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code> to keep the monotonicity on x axis or y axis.</p>\n<p>It is usually used on dual value axis.</p>\n<p>Here are 2 examples of broken line chart with dual value axis, showing the differences when <code class=\"codespan\">smoothMonotone</code> is without any setting, and <code class=\"codespan\">smoothMonotone</code> is set as <code class=\"codespan\">&#39;x&#39;</code>.</p>\n<ul>\n<li>No setting about <code class=\"codespan\">smoothMonotone</code>:</li>\n</ul>\n<p><img width=\"300\" height=\"auto\" src=\"documents/asset/img/smooth-monotone-none.png\"></p>\n<ul>\n<li>It is set as <code class=\"codespan\">&#39;x&#39;</code>:</li>\n</ul>\n<p><img width=\"300\" height=\"auto\" src=\"documents/asset/img/smooth-monotone-x.png\"></p>\n"},"sampling":{"type":["string"],"description":"<p>The dowmsampling strategy used when the data size is much larger than pixel size. It will improve the performance when turned on. Defaults to be turned off, indicating that all the data points will be drawn.</p>\n<p>Options:</p>\n<ul>\n<li><code class=\"codespan\">&#39;lttb&#39;</code> Use Largest-Triangle-Three-Bucket algorithm to filter points. It will keep the trends and extremas.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> Use average value of filter points</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> Use maximum value of filter points</li>\n<li><code class=\"codespan\">&#39;min&#39;</code> Use minimum value of filter points</li>\n<li><code class=\"codespan\">&#39;sum&#39;</code> Use sum of filter points</li>\n</ul>\n"},"dimensions":{"type":["Array"],"description":"<p><code class=\"codespan\">dimensions</code> can be used to define dimension info for <code class=\"codespan\">series.data</code> or <code class=\"codespan\">dataset.source</code>.</p>\n<p>Notice: if <a href=\"#dataset\">dataset</a> is used, we can definite dimensions in <a href=\"#dataset.dimensions\">dataset.dimensions</a>, or provide dimension names in the first column/row of <a href=\"#dataset.source\">dataset.source</a>, and not need to specify <code class=\"codespan\">dimensions</code> here. But if <code class=\"codespan\">dimensions</code> is specified here, it will be used despite the dimension definitions in dataset.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // &#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        // Specify name for each dimesions, which will be displayed in tooltip.\n        dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [\n        null,                // If you do not intent to defined this dimension, use null is fine.\n        {type: &#39;ordinal&#39;},   // Specify type of this dimension.\n                             // &#39;ordinal&#39; is always used in string.\n                             // If type is not specified, echarts will guess type by data.\n        {name: &#39;good&#39;, type: &#39;number&#39;},\n        &#39;bad&#39;                // Equals to {name: &#39;bad&#39;}.\n    ]\n}\n</code></pre>\n<p>Each data item of <code class=\"codespan\">dimensions</code> can be:</p>\n<ul>\n<li><code class=\"codespan\">string</code>, for example, <code class=\"codespan\">&#39;someName&#39;</code>, which equals to <code class=\"codespan\">{name: &#39;someName&#39;}</code>.</li>\n<li><code class=\"codespan\">Object</code>, where the attributes can be:<ul>\n<li>name: <code class=\"codespan\">string</code>.</li>\n<li>type: <code class=\"codespan\">string</code>, supports:<ul>\n<li><code class=\"codespan\">number</code></li>\n<li><code class=\"codespan\">float</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array\" target=\"_blank\">Float64Array</a></li>\n<li><code class=\"codespan\">int</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array\" target=\"_blank\">Int32Array</a></li>\n<li><code class=\"codespan\">ordinal</code>, discrete value, which represents string generally.</li>\n<li><code class=\"codespan\">time</code>, time value, see <a href=\"#series.data\">data</a> to check the format of time value.</li>\n</ul>\n</li>\n<li>displayName: <code class=\"codespan\">string</code>, generally used in tooltip for dimension display. If not specified, use <code class=\"codespan\">name</code> by default.</li>\n</ul>\n</li>\n</ul>\n<p>When <code class=\"codespan\">dimensions</code> is specified, the default <code class=\"codespan\">tooltip</code> will be displayed vertically, which is better to show diemsion names. Otherwise, <code class=\"codespan\">tooltip</code> will displayed only value horizontally.</p>\n"},"encode":{"type":["Object"],"description":"<p>Define what is encoded to for each dimension of <code class=\"codespan\">data</code>. For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // Each column is called a dimension.\n            // There are five dimensions: 0, 1, 2, 3, 4.\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        encode: {\n            x: [3, 1, 5],      // Dimension 3, 1, 5 is mapped to x axis.\n            y: 2,              // Dimension 2 is mapped to y axis.\n            tooltip: [3, 2, 4] // Dimension 3, 2, 4 will be displayed in tooltip.\n        }\n    }\n}\n</code></pre>\n<p>When <a href=\"#series.dimensions\">dimensions</a> is used to defined name for a certain dimension, <code class=\"codespan\">encode</code> can refer the name directly. For example:</p>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;],\n    encode: {\n        x: &#39;date&#39;,\n        y: [&#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<p>The basic structure of <a href=\"option.html#series.encode\" target=\"_blank\">encode</a> is illustrated as follows, where the left part of colon is the name of axis like <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code> or some special reserved names like &quot;tooltip&quot;, &quot;itemName&quot; etc., and the right part of the colon is the dimension names or dimension indices (based on 0). One or more dimensions can be specified. Usually not all of mappings need to be specified, only specify needed ones.</p>\n<p>The properties available in <code class=\"codespan\">encode</code> listed as follows:</p>\n<pre><code class=\"lang-js\">// In any of the series and coordinate systems,\n// these properties are available:\nencode: {\n    // Display dimension &quot;product&quot; and &quot;score&quot; in the tooltip.\n    tooltip: [&#39;product&#39;, &#39;score&#39;]\n    // Set the series name as the concat of the names of dimensions[1] and dimensions[3].\n    // (sometimes the dimension names are too long to type in series.name manually).\n    seriesName: [1, 3],\n    // Using dimensions[2] as the id of each data item. This is useful when dynamically\n    // update data by `chart.setOption()`, where the new and old data item can be\n    // corresponded by id, by which the appropriate animation can be performed when updating.\n    itemId: 2,\n    // Using dimensions[3] as the name of each data item. This is useful in charts like\n    // &#39;pie&#39;, &#39;funnel&#39;, where data item name can be displayed in legend.\n    itemName: 3\n}\n\n// These properties only work in cartesian(grid) coordinate system:\nencode: {\n    // Map dimensions[1], dimensions[5] and dimension &quot;score&quot; to the X axis.\n    x: [1, 5, &#39;score&#39;],\n    // Map dimensions[0] to the Y axis.\n    y: 0\n}\n\n// These properties only work in polar coordinate system:\nencode: {\n    radius: 3,\n    angle: 2,\n    ...\n}\n\n// These properties only work in geo coordinate system:\nencode: {\n    lng: 3,\n    lat: 2\n}\n\n// For some type of series that are not in any coordinate system,\n// like &#39;pie&#39;, &#39;funnel&#39; etc.:\nencode: {\n    value: 3\n}\n</code></pre>\n<p>This is an <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=dataset-encode1&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> for <code class=\"codespan\">encode</code>.</p>\n<p>Specially, in [custom series(~series-custom), some property in <code class=\"codespan\">encode</code>, corresponding to axis, can be set as null to make the series not controlled by the axis, that is, the series data will not be count in the extent of the axis, and the <a href=\"#dataZoom\">dataZoom</a> on the axis will not filter the series.</p>\n<pre><code class=\"lang-js\">var option = {\n    xAxis: {},\n    yAxis: {},\n    dataZoom: [{\n        xAxisIndex: 0\n    }, {\n        yAxisIndex: 0\n    }],\n    series: {\n        type: &#39;custom&#39;,\n        renderItem: function (params, api) {\n            return {\n                type: &#39;circle&#39;,\n                shape: {\n                    cx: 100, // x position is always 100\n                    cy: api.coord([0, api.value(0)])[1],\n                    r: 30\n                },\n                style: {\n                    fill: &#39;blue&#39;\n                }\n            };\n        },\n        encode: {\n            // Then the series will not be controlled\n            // by x axis and corresponding dataZoom.\n            x: -1,\n            y: 1\n        },\n        data: [ ... ]\n    }\n};\n</code></pre>\n"},"seriesLayoutBy":{"type":["string"],"description":"<p>When <a href=\"#dataset\">dataset</a> is used, <code class=\"codespan\">seriesLayoutBy</code> specifies whether the column or the row of <code class=\"codespan\">dataset</code> is mapped to the series, namely, the series is &quot;layout&quot; on columns or rows. Optional values:</p>\n<ul>\n<li>&#39;column&#39;: by default, the columns of <code class=\"codespan\">dataset</code> are mapped the series. In this case, each column represents a dimension.</li>\n<li>&#39;row&#39;：the rows of <code class=\"codespan\">dataset</code> are mapped to the series. In this case, each row represents a dimension.</li>\n</ul>\n<p>Check this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=dataset-series-layout-by\" target=\"_blank\">example</a>.</p>\n","default":"'column'"},"datasetIndex":{"type":["number"],"description":"<p>If <a href=\"#series.data\">series.data</a> is not specified, and <a href=\"#dataset\">dataset</a> exists, the series will use <code class=\"codespan\">dataset</code>. <code class=\"codespan\">datasetIndex</code> specifies which dataset will be used.</p>\n","default":0},"data":{"type":["Array"],"description":"<p>Data array of series, which can be in the following forms:</p>\n<p>Notice, if no <code class=\"codespan\">data</code> specified in series, and there is <a href=\"#dataset\">dataset</a> in option, series will use the first <a href=\"#dataset\">dataset</a> as its datasource. If <code class=\"codespan\">data</code> has been specified, <a href=\"#dataset\">dataset</a> will not used.</p>\n<p><code class=\"codespan\">series.datasetIndex</code> can be used to specify other <a href=\"#dataset\">dataset</a>.</p>\n<p>Basically, data is represented by a two-dimension array, like the example below, where each column is named as a &quot;dimension&quot;.</p>\n<pre><code class=\"lang-js\">series: [{\n    data: [\n        // dimX   dimY   other dimensions ...\n        [  3.4,    4.5,   15,   43],\n        [  4.2,    2.3,   20,   91],\n        [  10.8,   9.5,   30,   18],\n        [  7.2,    8.8,   18,   57]\n    ]\n}]\n</code></pre>\n<ul>\n<li>In <a href=\"#grid\">cartesian (grid)</a>, &quot;dimX&quot; and &quot;dimY&quot; correspond to <a href=\"#xAxis\">xAxis</a> and <a href=\"#yAxis\">yAxis</a> respectively.</li>\n<li>In <a href=\"#polar\">polar</a> &quot;dimX&quot; and &quot;dimY&quot; correspond to <a href=\"#radiusAxis\">radiusAxis</a> 和 <a href=\"#anbleAxis\">angleAxis</a> respectively.</li>\n<li>Other dimensions are optional, which can be used in other places. For example:<ul>\n<li><a href=\"#visualMap\">visualMap</a> can map one or more dimensions to visual (color, symbol size ...).</li>\n<li><a href=\"#series.symbolSize\">series.symbolSize</a> can be set as a callback function, where symbol size can be calculated by values of a certain dimension.</li>\n<li>Values in other dimensions can be shown by <a href=\"#tooltip.formatter\">tooltip.formatter</a> or <a href=\"#series.label.formatter\">series.label.formatter</a>.</li>\n</ul>\n</li>\n</ul>\n<p>Especially, when there is one and only one category axis (axis.type is <code class=\"codespan\">&#39;category&#39;</code>), data can be simply be represented by a one-dimension array, like:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    data: [&#39;a&#39;, &#39;b&#39;, &#39;m&#39;, &#39;n&#39;]\n},\nseries: [{\n    // Each item corresponds to each item in xAxis.data.\n    data: [23,  44,  55,  19]\n    // In fact, it is the simplification of the format below:\n    // data: [[0, 23], [1, 44], [2, 55], [3, 19]]\n}]\n</code></pre>\n<p><br>\n<strong>Relationship between &quot;value&quot; and <a href=\"#xAxis.type\">axis.type</a></strong></p>\n<ul>\n<li><p>When a dimension corresponds to a value axis (axis.type is <code class=\"codespan\">&#39;value&#39;</code> or <code class=\"codespan\">&#39;log&#39;</code>):</p>\n<p>  The value can be a <code class=\"codespan\">number</code> (like <code class=\"codespan\">12</code>) (can also be a number in a <code class=\"codespan\">string</code> format, like <code class=\"codespan\">&#39;12&#39;</code>).</p>\n</li>\n<li><p>When a dimension corresponds to a category axis (axis.type is <code class=\"codespan\">&#39;category&#39;</code>):</p>\n<p>  The value should be the ordinal of the axis.data (based on <code class=\"codespan\">0</code>), the string value of the axis.data. For example:</p>\n<pre><code class=\"lang-js\">  xAxis: {\n      type: &#39;category&#39;,\n      data: [&#39;Monday&#39;, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;]\n  },\n  yAxis: {\n      type: &#39;category&#39;,\n      data: [&#39;a&#39;, &#39;b&#39;, &#39;m&#39;, &#39;n&#39;, &#39;p&#39;, &#39;q&#39;]\n  },\n  series: [{\n      data: [\n          // xAxis      yAxis\n          [  0,           0,    2  ], // This point is located at xAxis: &#39;Monday&#39;, yAxis: &#39;a&#39;.\n          [  &#39;Thursday&#39;,  2,    1  ], // This point is located at xAxis: &#39;Thursday&#39;, yAxis: &#39;m&#39;.\n          [  2,          &#39;p&#39;,   2  ], // This point is located at xAxis: &#39;Wednesday&#39;, yAxis: &#39;p&#39;.\n          [  3,           3,    5  ]\n      ]\n  }]\n</code></pre>\n<p>  There is an example of double category axes: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-punchCard\" target=\"_blank\">Github Punchcard</a>.</p>\n</li>\n<li><p>When a dimension corresponds to a time axis (type is <code class=\"codespan\">&#39;time&#39;</code>), the value can be:</p>\n<ul>\n<li>a timestamp, like <code class=\"codespan\">1484141700832</code>, which represents a UTC time.</li>\n<li>a date string, in one of the formats below:<ul>\n<li>a subset of <a href=\"http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15\" target=\"_blank\">ISO 8601</a>, only including (all of these are treated as local time unless timezone is specified, which is consistent with <a href=\"https://momentjs.com/\" target=\"_blank\">moment</a>):<ul>\n<li>only part of year/month/date/time are specified: <code class=\"codespan\">&#39;2012-03&#39;</code>, <code class=\"codespan\">&#39;2012-03-01&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 05&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 05:06&#39;</code>.</li>\n<li>separated by <code class=\"codespan\">&quot;T&quot;</code> or a space: <code class=\"codespan\">&#39;2012-03-01T12:22:33.123&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 12:22:33.123&#39;</code>.</li>\n<li>timezone specified: <code class=\"codespan\">&#39;2012-03-01T12:22:33Z&#39;</code>, <code class=\"codespan\">&#39;2012-03-01T12:22:33+8000&#39;</code>, <code class=\"codespan\">&#39;2012-03-01T12:22:33-05:00&#39;</code>.</li>\n</ul>\n</li>\n<li>other date string format (all of these are treated as local time):\n<code class=\"codespan\">&#39;2012&#39;</code>, <code class=\"codespan\">&#39;2012-3-1&#39;</code>, <code class=\"codespan\">&#39;2012/3/1&#39;</code>, <code class=\"codespan\">&#39;2012/03/01&#39;</code>,\n<code class=\"codespan\">&#39;2009/6/12 2:00&#39;</code>, <code class=\"codespan\">&#39;2009/6/12 2:05:08&#39;</code>, <code class=\"codespan\">&#39;2009/6/12 2:05:08.123&#39;</code>.</li>\n</ul>\n</li>\n<li>a JavaScript Date instance created by user:<ul>\n<li>Caution, when using a data string to create a Date instance, <a href=\"http://dygraphs.com/date-formats.html\" target=\"_blank\">browser differences and inconsistencies</a> should be considered.</li>\n<li>For example: In chrome, <code class=\"codespan\">new Date(&#39;2012-01-01&#39;)</code> is treated as a Jan 1st 2012 in UTC, while <code class=\"codespan\">new Date(&#39;2012-1-1&#39;)</code> and <code class=\"codespan\">new Date(&#39;2012/01/01&#39;)</code> are treated as Jan 1st 2012 in local timezone. In safari <code class=\"codespan\">new Date(&#39;2012-1-1&#39;)</code> is not supported.</li>\n<li>So if you intent to perform <code class=\"codespan\">new Date(dateString)</code>, it is strongly recommended to use a time parse library (e.g., <a href=\"https://momentjs.com/\" target=\"_blank\">moment</a>), or use <code class=\"codespan\">echarts.number.parseDate</code>, or check <a href=\"http://dygraphs.com/date-formats.html\" target=\"_blank\">this</a>.</li>\n</ul>\n</li>\n</ul>\n</li>\n</ul>\n<p><br>\n<strong>Customize a data item:</strong></p>\n<p>When needing to customize a data item, it can be set as an object, where property <code class=\"codespan\">value</code> reprensent real value. For example:</p>\n<pre><code class=\"lang-js\">[\n    12,\n    24,\n    {\n        value: [24, 32],\n        // label style, only works in this data item.\n        label: {},\n        // item style, only works in this data item.\n        itemStyle:{}\n    },\n    33\n]\n// Or\n[\n    [12, 332],\n    [24, 32],\n    {\n        value: [24, 32],\n        // label style, only works in this data item.\n        label: {},\n        // item style, only works in this data item.\n        itemStyle:{}\n    },\n    [33, 31]\n]\n</code></pre>\n<p><br>\n<strong>Empty value:</strong></p>\n<p><code class=\"codespan\">&#39;-&#39;</code> or <code class=\"codespan\">null</code> or <code class=\"codespan\">undefined</code> or <code class=\"codespan\">NaN</code> can be used to describe that a data item does not exist (ps：<em>not exist</em> does not means its value is <code class=\"codespan\">0</code>).</p>\n<p>For example, line chart can break when encounter an empty value, and scatter chart do not display graphic elements for empty values.</p>\n<p><br><br></p>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>The name of data item.</p>\n"},"value":{"type":["number"],"description":"<p>The value of a single data item.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of single data.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"},"default":"'circle'"},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>single data symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"},"default":4},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of single data symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of single data symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"label":{"type":["Object"],"description":"<p>The style of the text of single data point.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"top"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>The style of the symbol of single data point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of specified single data.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<p>Blur state of specified single data.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<p>Select state of specified single data.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series data.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}}},"markPoint":{"type":["Object"],"description":"<p>Mark point in a chart.</p>\n","properties":{"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-line.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'pin'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-line.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":50},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-line.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label of mark point.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark point.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Data array for mark points, each of which is an object. Here are some ways to assign mark point position.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-line.markPoint.data.x\">x</a>, <a href=\"#series-line.markPoint.data.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li><p>Assign coordinate position with <a href=\"#series-line.markPoint.data.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</p>\n</li>\n<li><p>Use <a href=\"#series-line.markPoint.data.type\">type</a> attribute to mark the maximum and minimum values in the series, in which <a href=\"#series-line.markPoint.data.valueIndex\">valueIndex</a> or <a href=\"#series-line.markPoint.data.valueDim\">valueDim</a> can be used to assign the dimension.</p>\n</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p><strong>For example: </strong></p>\n<pre><code class=\"lang-js\">data: [\n    {\n        name: &#39;maximum&#39;,\n        type: &#39;max&#39;\n    }, \n    {\n        name: &#39;coordinate&#39;,\n        coord: [10, 20]\n    }, {\n        name: &#39;fixed x position&#39;,\n        yAxis: 10,\n        x: &#39;90%&#39;\n    }, \n\n    {\n        name: &#39;screen coordinate&#39;,\n        x: 100,\n        y: 100\n    }\n]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Mark point name.</p>\n","default":"''"},"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Available when using <a href=\"#series-line.markPoint.data.type\">type</a> it is used to assign maximum value and minimum value in dimensions, it could be <code class=\"codespan\">0</code> (xAxis, radiusAxis), <code class=\"codespan\">1</code> (yAxis, angleAxis), and use the first value axis dimension by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-line.markPoint.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markLine":{"type":["Object"],"description":"<p>Use a line in the chart to illustrate.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"symbol":{"type":["string","Array"],"description":"<p>Symbol type at the two ends of the mark line. It can be an array for two ends, or assigned seperately. See <a href=\"#series-line.markLine.data.0.symbol\">data.symbol</a> for more format information.</p>\n"},"symbolSize":{"type":["number","Array"],"description":"<p>Symbol size at the two ends of the mark line. It can be an array for two ends, or assigned seperately.</p>\n<p><strong>Attention: </strong> You cannot assgin width and height seperately as normal <code class=\"codespan\">symbolSize</code>.</p>\n"},"precision":{"type":["number"],"description":"<p>Precision of marking line value, which is useful when displaying average value mark line.</p>\n","default":2},"label":{"type":["Object"],"description":"<p>Mark line text.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"<p>Mark line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark line.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>Data array of marking line. Every array item can be an array of one or two values, representing starting and ending point of the line, and every item is an object. Here are several ways to assign the positions of starting and ending point.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-line.markLine.data.0.x\">x</a>, <a href=\"#series-line.markLine.data.0.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li><p>Assign coordinate position with <a href=\"#series-line.markLine.data.0.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</p>\n</li>\n<li><p>Use <a href=\"#series-line.markLine.data.0.type\">type</a> attribute to mark the maximum and minimum values in the series, in which <a href=\"#series-line.markLine.data.0.valueIndex\">valueIndex</a> or <a href=\"#series-line.markLine.data.0.valueDim\">valueDim</a> can be used to assign the dimension.</p>\n</li>\n<li><p>You may also create a mark line in Cartesian coordinate at a specific position in X or Y axis by assigning <code class=\"codespan\">xAxis</code> or <code class=\"codespan\">yAxis</code>. See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-weight\" target=\"_blank\">scatter-weight</a> for example.</p>\n</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p>You may also set the type of mark line through <code class=\"codespan\">type</code>, stating whether it is for the maximum value or average value. Likewise, dimensions can be assigned through <code class=\"codespan\">valueIndex</code>.</p>\n<pre><code>data: [\n\n{\n        name: &#39;average line&#39;,\n        // &#39;average&#39;, &#39;min&#39;, and &#39;max&#39; are supported\n        type: &#39;average&#39;\n    },\n    {\n        name: &#39;Horizontal line with Y value at 100&#39;,\n        yAxis: 100\n    },\n    [\n        {\n            // Use the same name with starting and ending point\n            name: &#39;Minimum to Maximum&#39;,\n            type: &#39;min&#39;\n        },\n        {\n            type: &#39;max&#39;\n        }\n    ],\n[\n        {\n            name: &#39;Markline between two points&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [{\n        // Mark line with a fixed X position in starting point. This is used to generate an arrow pointing to maximum line.\n        yAxis: &#39;max&#39;,\n        x: &#39;90%&#39;\n    }, {\n        type: &#39;max&#39;\n    }],\n[\n        {\n            name: &#39;Mark line between two points&#39;,\n            x: 100,\n            y: 100\n        },\n        {\n            x: 500,\n            y: 200\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Data of the starting point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n<li><code class=\"codespan\">&#39;median&#39;</code> median value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-line.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-line.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'starting point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of starting point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>starting point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of starting point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of starting point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Data of the ending point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n<li><code class=\"codespan\">&#39;median&#39;</code> median value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-line.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-line.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'ending point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of ending point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>ending point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of ending point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of ending point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markArea":{"type":["Object"],"description":"<p>Used to mark an area in chart. For example, mark a time interval.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label in mark area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Style of the mark area.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark area.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>The scope of the area is defined by <code class=\"codespan\">data</code>, which is an array with two item, representing the left-top point and the right-bottom point of rectangle area. Each item can be defined as follows:</p>\n<ol>\n<li>Specify the coordinate in screen coordinate system using <a href=\"#series-line.markArea.data.0.x\">x</a>, <a href=\"#series-line.markArea.data.0.y\">y</a>, where the unit is pixel (e.g., the value is <code class=\"codespan\">5</code>), or percent (e.g., the value is <code class=\"codespan\">&#39;35%&#39;</code>).</li>\n</ol>\n<ol start=\"2\">\n<li><p>Specify the coordinate in data coordinate system (i.e., cartesian) using\n<a href=\"#series-line.markArea.data.0.coord\">coord</a>, which can be also set as <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> (e.g, <code class=\"codespan\">coord: [23, &#39;min&#39;]</code>, or <code class=\"codespan\">coord: [&#39;average&#39;, &#39;max&#39;]</code>).</p>\n</li>\n<li><p>Locate the point on the min value or max value of <code class=\"codespan\">series.data</code> using <a href=\"#series-line.markArea.data.0.type\">type</a>, where <a href=\"#series-line.markArea.data.0.valueIndex\">valueIndex</a> or <a href=\"#series-line.markPoint.data.0.valueDim\">valueDim</a> can be used to specify the dimension on which the min, max or average are calculated.</p>\n</li>\n<li>If in cartesian, you can only specify <code class=\"codespan\">xAxis</code> or <code class=\"codespan\">yAxis</code> to define a mark area based on only X or Y axis, see sample <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-weight\" target=\"_blank\">scatter-weight</a></li>\n</ol>\n<p>The priority follows as above if more than one above definition used.</p>\n<pre><code>data: [\n\n\n    [\n        {\n            name: &#39;From average to max&#39;,\n            type: &#39;average&#39;\n        },\n        {\n            type: &#39;max&#39;\n        }\n    ],\n\n    [\n        {\n            name: &#39;Mark area between two points in data coordiantes&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [\n        {\n            name: &#39;From 60 to 80&#39;,\n            yAxis: 60\n        },\n        {\n            yAxis: 80\n        }\n    ], [\n        {\n            name: &#39;Mark area covers all data&#39;\n            coord: [&#39;min&#39;, &#39;min&#39;]\n        },\n        {\n            coord: [&#39;max&#39;, &#39;max&#39;]\n        }\n    ],\n[\n        {\n            name: &#39;Mark area in two screen points&#39;,\n            x: 100,\n            y: 100\n        }, {\n            x: &#39;90%&#39;,\n            y: &#39;10%&#39;\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Specify the left-top point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Specify this item is on min or max or average value.</p>\n<p><strong>Options:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> max value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> min value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-line.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-line.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'start'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Specify the right-bottom point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Specify this item is on min or max or average value.</p>\n<p><strong>Options:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> max value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> min value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-line.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-line.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'end'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"false","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in Line.</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in Line, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"linear"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p><strong>bar chart</strong></p>\n<p>Bar chart shows different data through the height of a bar, which is used in <a href=\"#grid\">rectangular coordinate</a> with at least 1 category axis.</p>\n","properties":{"type":{"type":["string"],"description":"","default":"'bar'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"legendHoverLink":{"type":["boolean"],"description":"\n\n<p>Whether to enable highlighting chart when <a href=\"#legend\">legend</a> is being hovered.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"coordinateSystem":{"type":["string"],"description":"<p>The coordinate used in the series, whose options are:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;cartesian2d&#39;</code></p>\n<p>  Use a two-dimensional rectangular coordinate (also known as Cartesian coordinate), with <a href=\"#series-bar.xAxisIndex\">xAxisIndex</a> and <a href=\"#series-bar.yAxisIndex\">yAxisIndex</a> to assign the corresponding axis component.</p>\n</li>\n</ul>\n","default":"'cartesian2d'"},"xAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#xAxis\">x axis</a> to combine with, which is  useful for multiple x axes in one chart.</p>\n","default":0},"yAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#yAxis\">y axis</a> to combine with, which is  useful for multiple y axes in one chart.</p>\n","default":0},"roundCap":{"type":["boolean"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v4.5.0</code></p>\n</blockquote>\n\n\n<p>Whether to add round caps at the end of the bar sectors. Valid only for bar series on polar coordinates.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=polar-roundCap&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"showBackground":{"type":["boolean"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.7.0</code></p>\n</blockquote>\n\n\n<p>Whether to show background behind each bar. Use <a href=\"#series-bar.backgroundStyle\">backgroundStyle</a> to set background style.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-background&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"backgroundStyle":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.7.0</code></p>\n</blockquote>\n<p>Background style of each bar if <a href=\"#series-bar.showBackground\">showBackground</a> is set to be <code class=\"codespan\">true</code>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-background&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Bar color. </p>\n","uiControl":{"type":"color"},"default":"'rgba(180, 180, 180, 0.2)'"},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color of bar.</p>\n","uiControl":{"type":"color","value":"#000"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of bar. defaults to have no border.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type. Can be <code class=\"codespan\">&#39;dashed&#39;</code>, <code class=\"codespan\">&#39;dotted&#39;</code>.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>The radius of rounded corner. Its unit is px. And it supports use array to respectively specify the 4 corner radiuses.</p>\n<p>For example:</p>\n<pre><code>borderRadius: 5, // consistently set the size of 4 rounded corners\nborderRadius: [5, 5, 0, 0] // (clockwise upper left, upper right, bottom right and bottom left)\n</code></pre>","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"},"default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of , <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Bar color. </p>\n","uiControl":{"type":"color"},"default":"auto"},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color of bar.</p>\n","uiControl":{"type":"color","value":"#000"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of bar. defaults to have no border.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type. Can be <code class=\"codespan\">&#39;dashed&#39;</code>, <code class=\"codespan\">&#39;dotted&#39;</code>.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>The radius of rounded corner. Its unit is px. And it supports use array to respectively specify the 4 corner radiuses.</p>\n<p>For example:</p>\n<pre><code>borderRadius: 5, // consistently set the size of 4 rounded corners\nborderRadius: [5, 5, 0, 0] // (clockwise upper left, upper right, bottom right and bottom left)\n</code></pre>","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"},"default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"emphasis":{"type":["Object"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"label":{"type":["Object"],"description":"<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of , <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Bar color. </p>\n","uiControl":{"type":"color"},"default":"auto"},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color of bar.</p>\n","uiControl":{"type":"color","value":"#000"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of bar. defaults to have no border.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type. Can be <code class=\"codespan\">&#39;dashed&#39;</code>, <code class=\"codespan\">&#39;dotted&#39;</code>.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>The radius of rounded corner. Its unit is px. And it supports use array to respectively specify the 4 corner radiuses.</p>\n<p>For example:</p>\n<pre><code>borderRadius: 5, // consistently set the size of 4 rounded corners\nborderRadius: [5, 5, 0, 0] // (clockwise upper left, upper right, bottom right and bottom left)\n</code></pre>","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"},"default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<p>Configurations of blur state. Available when <a href=\"#series-bar.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of , <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Bar color. </p>\n","uiControl":{"type":"color"},"default":"auto"},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color of bar.</p>\n","uiControl":{"type":"color","value":"#000"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of bar. defaults to have no border.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type. Can be <code class=\"codespan\">&#39;dashed&#39;</code>, <code class=\"codespan\">&#39;dotted&#39;</code>.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>The radius of rounded corner. Its unit is px. And it supports use array to respectively specify the 4 corner radiuses.</p>\n<p>For example:</p>\n<pre><code>borderRadius: 5, // consistently set the size of 4 rounded corners\nborderRadius: [5, 5, 0, 0] // (clockwise upper left, upper right, bottom right and bottom left)\n</code></pre>","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"},"default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<p>Configurations of select state. Available when <a href=\"#series-bar.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of , <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Bar color. </p>\n","uiControl":{"type":"color"},"default":"auto"},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color of bar.</p>\n","uiControl":{"type":"color","value":"#000"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of bar. defaults to have no border.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type. Can be <code class=\"codespan\">&#39;dashed&#39;</code>, <code class=\"codespan\">&#39;dotted&#39;</code>.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>The radius of rounded corner. Its unit is px. And it supports use array to respectively specify the 4 corner radiuses.</p>\n<p>For example:</p>\n<pre><code>borderRadius: 5, // consistently set the size of 4 rounded corners\nborderRadius: [5, 5, 0, 0] // (clockwise upper left, upper right, bottom right and bottom left)\n</code></pre>","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"},"default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"stack":{"type":["string"],"description":"<p>Name of stack. On the same category axis, the series with the same <code class=\"codespan\">stack</code> name would be put on top of each other.</p>\n","default":null},"sampling":{"type":["string"],"description":"<p>The dowmsampling strategy used when the data size is much larger than pixel size. It will improve the performance when turned on. Defaults to be turned off, indicating that all the data points will be drawn.</p>\n<p>Options:</p>\n<ul>\n<li><code class=\"codespan\">&#39;lttb&#39;</code> Use Largest-Triangle-Three-Bucket algorithm to filter points. It will keep the trends and extremas.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> Use average value of filter points</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> Use maximum value of filter points</li>\n<li><code class=\"codespan\">&#39;min&#39;</code> Use minimum value of filter points</li>\n<li><code class=\"codespan\">&#39;sum&#39;</code> Use sum of filter points</li>\n</ul>\n"},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"barWidth":{"type":["number","string"],"description":"<p>The width of the bar. Adaptive when not specified.</p>\n\n\n\n\n<p>Can be an absolute value like <code class=\"codespan\">40</code> or a percent value like <code class=\"codespan\">&#39;60%&#39;</code>. The percent is based on the calculated category width.</p>\n<p>In a single coodinate system, this attribute is shared by multiple <code class=\"codespan\">&#39;bar&#39;</code> series. This attribute should be set on the last <code class=\"codespan\">&#39;bar&#39;</code> series in the coodinate system, then it will be adopted by all <code class=\"codespan\">&#39;bar&#39;</code> series in the coordinate system.</p>\n","uiControl":{"type":"percent"},"default":null},"barMaxWidth":{"type":["number","string"],"description":"<p>The maximum width of the bar.</p>\n<p>Has higer priority than <a href=\"#series-bar.barWidth\">barWidth</a>.</p>\n<p>Can be an absolute value like <code class=\"codespan\">40</code> or a percent value like <code class=\"codespan\">&#39;60%&#39;</code>. The percent is based on the calculated category width.</p>\n<p>In a single coodinate system, this attribute is shared by multiple <code class=\"codespan\">&#39;bar&#39;</code> series. This attribute should be set on the last <code class=\"codespan\">&#39;bar&#39;</code> series in the coodinate system, then it will be adopted by all <code class=\"codespan\">&#39;bar&#39;</code> series in the coordinate system.</p>\n","default":null},"barMinWidth":{"type":["number","string"],"description":"<p>The minimum width of the bar. In cartesian the default value is <code class=\"codespan\">1</code>, otherwise the default value if <code class=\"codespan\">null</code>.</p>\n<p>Has higer priority than <a href=\"#series-bar.barWidth\">barWidth</a>.</p>\n<p>Can be an absolute value like <code class=\"codespan\">40</code> or a percent value like <code class=\"codespan\">&#39;60%&#39;</code>. The percent is based on the calculated category width.</p>\n<p>In a single coodinate system, this attribute is shared by multiple <code class=\"codespan\">&#39;bar&#39;</code> series. This attribute should be set on the last <code class=\"codespan\">&#39;bar&#39;</code> series in the coodinate system, then it will be adopted by all <code class=\"codespan\">&#39;bar&#39;</code> series in the coordinate system.</p>\n"},"barMinHeight":{"type":["number"],"description":"<p>The minimum width of bar. It could be used to avoid the following situation: the interaction would be affected when the value of some data item is too small.</p>\n\n","uiControl":{"type":"number","min":"0"},"default":0},"barGap":{"type":["string"],"description":"<p>The gap between bars between different series, is a percent value like <code class=\"codespan\">&#39;30%&#39;</code>, which means <code class=\"codespan\">30%</code> of the bar width.</p>\n<p>Set barGap as <code class=\"codespan\">&#39;-100%&#39;</code> can overlap bars that belong to different series, which is useful when making a series of bar be background.</p>\n<p>In a single coodinate system, this attribute is shared by multiple <code class=\"codespan\">&#39;bar&#39;</code> series. This attribute should be set on the last <code class=\"codespan\">&#39;bar&#39;</code> series in the coodinate system, then it will be adopted by all <code class=\"codespan\">&#39;bar&#39;</code> series in the coordinate system.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/barGrid-barGap&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"30%"},"barCategoryGap":{"type":["string"],"description":"<p>The bar gap of a single series, defaults to be <code class=\"codespan\">20%</code> of the category gap, can be set as a fixed value.</p>\n<p>In a single coodinate system, this attribute is shared by multiple <code class=\"codespan\">&#39;bar&#39;</code> series. This attribute should be set on the last <code class=\"codespan\">&#39;bar&#39;</code> series in the coodinate system, then it will be adopted by all <code class=\"codespan\">&#39;bar&#39;</code> series in the coordinate system.</p>\n","default":"'20%'"},"large":{"type":["boolean"],"description":"\n\n<p>Whether to enable the optimization of large-scale data. It could be set when large data causes performance problem.</p>\n<p>After being enabled, <code class=\"codespan\">largeThreshold</code> can be used to indicate the minimum number for turning on the optimization.</p>\n<p>But when the optimization enabled, the style of single data item can&#39;t be customized any more.</p>\n","uiControl":{"type":"boolean"},"default":false},"largeThreshold":{"type":["number"],"description":"\n\n<p>The threshold enabling the drawing optimization.</p>\n","uiControl":{"type":"number","min":"1","default":"400"},"default":400},"progressive":{"type":["number"],"description":"<p><code class=\"codespan\">progressive</code> specifies the amount of graphic elements that can be rendered within a frame (about 16ms) if &quot;progressive rendering&quot; enabled.</p>\n<p>When data amount is from thousand to more than 10 million, it will take too long time to render all of the graphic elements. Since ECharts 4, &quot;progressive rendering&quot; is supported in its workflow, which processes and renders data chunk by chunk alone with each frame, avoiding to block the UI thread of the browser.</p>\n<p>Set <code class=\"codespan\">progressive: 0</code> to disable progressive permanently. By default, progressive is auto-enabled when data amount is bigger than <code class=\"codespan\">progressiveThreshold</code>.</p>\n","default":5000},"progressiveThreshold":{"type":["number"],"description":"<p>If current data amount is over the threshold, &quot;progressive rendering&quot; is enabled.</p>\n","default":3000},"progressiveChunkMode":{"type":["string"],"description":"<p>Chunk approach, optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;sequential&#39;</code>: slice data by data index.</li>\n<li><code class=\"codespan\">&#39;mod&#39;</code>: slice data by mod, which make the data items of each chunk coming from all over the data, bringing better visual effect while progressive rendering.</li>\n</ul>\n","default":"mod"},"dimensions":{"type":["Array"],"description":"<p><code class=\"codespan\">dimensions</code> can be used to define dimension info for <code class=\"codespan\">series.data</code> or <code class=\"codespan\">dataset.source</code>.</p>\n<p>Notice: if <a href=\"#dataset\">dataset</a> is used, we can definite dimensions in <a href=\"#dataset.dimensions\">dataset.dimensions</a>, or provide dimension names in the first column/row of <a href=\"#dataset.source\">dataset.source</a>, and not need to specify <code class=\"codespan\">dimensions</code> here. But if <code class=\"codespan\">dimensions</code> is specified here, it will be used despite the dimension definitions in dataset.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // &#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        // Specify name for each dimesions, which will be displayed in tooltip.\n        dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [\n        null,                // If you do not intent to defined this dimension, use null is fine.\n        {type: &#39;ordinal&#39;},   // Specify type of this dimension.\n                             // &#39;ordinal&#39; is always used in string.\n                             // If type is not specified, echarts will guess type by data.\n        {name: &#39;good&#39;, type: &#39;number&#39;},\n        &#39;bad&#39;                // Equals to {name: &#39;bad&#39;}.\n    ]\n}\n</code></pre>\n<p>Each data item of <code class=\"codespan\">dimensions</code> can be:</p>\n<ul>\n<li><code class=\"codespan\">string</code>, for example, <code class=\"codespan\">&#39;someName&#39;</code>, which equals to <code class=\"codespan\">{name: &#39;someName&#39;}</code>.</li>\n<li><code class=\"codespan\">Object</code>, where the attributes can be:<ul>\n<li>name: <code class=\"codespan\">string</code>.</li>\n<li>type: <code class=\"codespan\">string</code>, supports:<ul>\n<li><code class=\"codespan\">number</code></li>\n<li><code class=\"codespan\">float</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array\" target=\"_blank\">Float64Array</a></li>\n<li><code class=\"codespan\">int</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array\" target=\"_blank\">Int32Array</a></li>\n<li><code class=\"codespan\">ordinal</code>, discrete value, which represents string generally.</li>\n<li><code class=\"codespan\">time</code>, time value, see <a href=\"#series.data\">data</a> to check the format of time value.</li>\n</ul>\n</li>\n<li>displayName: <code class=\"codespan\">string</code>, generally used in tooltip for dimension display. If not specified, use <code class=\"codespan\">name</code> by default.</li>\n</ul>\n</li>\n</ul>\n<p>When <code class=\"codespan\">dimensions</code> is specified, the default <code class=\"codespan\">tooltip</code> will be displayed vertically, which is better to show diemsion names. Otherwise, <code class=\"codespan\">tooltip</code> will displayed only value horizontally.</p>\n"},"encode":{"type":["Object"],"description":"<p>Define what is encoded to for each dimension of <code class=\"codespan\">data</code>. For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // Each column is called a dimension.\n            // There are five dimensions: 0, 1, 2, 3, 4.\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        encode: {\n            x: [3, 1, 5],      // Dimension 3, 1, 5 is mapped to x axis.\n            y: 2,              // Dimension 2 is mapped to y axis.\n            tooltip: [3, 2, 4] // Dimension 3, 2, 4 will be displayed in tooltip.\n        }\n    }\n}\n</code></pre>\n<p>When <a href=\"#series.dimensions\">dimensions</a> is used to defined name for a certain dimension, <code class=\"codespan\">encode</code> can refer the name directly. For example:</p>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;],\n    encode: {\n        x: &#39;date&#39;,\n        y: [&#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<p>The basic structure of <a href=\"option.html#series.encode\" target=\"_blank\">encode</a> is illustrated as follows, where the left part of colon is the name of axis like <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code> or some special reserved names like &quot;tooltip&quot;, &quot;itemName&quot; etc., and the right part of the colon is the dimension names or dimension indices (based on 0). One or more dimensions can be specified. Usually not all of mappings need to be specified, only specify needed ones.</p>\n<p>The properties available in <code class=\"codespan\">encode</code> listed as follows:</p>\n<pre><code class=\"lang-js\">// In any of the series and coordinate systems,\n// these properties are available:\nencode: {\n    // Display dimension &quot;product&quot; and &quot;score&quot; in the tooltip.\n    tooltip: [&#39;product&#39;, &#39;score&#39;]\n    // Set the series name as the concat of the names of dimensions[1] and dimensions[3].\n    // (sometimes the dimension names are too long to type in series.name manually).\n    seriesName: [1, 3],\n    // Using dimensions[2] as the id of each data item. This is useful when dynamically\n    // update data by `chart.setOption()`, where the new and old data item can be\n    // corresponded by id, by which the appropriate animation can be performed when updating.\n    itemId: 2,\n    // Using dimensions[3] as the name of each data item. This is useful in charts like\n    // &#39;pie&#39;, &#39;funnel&#39;, where data item name can be displayed in legend.\n    itemName: 3\n}\n\n// These properties only work in cartesian(grid) coordinate system:\nencode: {\n    // Map dimensions[1], dimensions[5] and dimension &quot;score&quot; to the X axis.\n    x: [1, 5, &#39;score&#39;],\n    // Map dimensions[0] to the Y axis.\n    y: 0\n}\n\n// These properties only work in polar coordinate system:\nencode: {\n    radius: 3,\n    angle: 2,\n    ...\n}\n\n// These properties only work in geo coordinate system:\nencode: {\n    lng: 3,\n    lat: 2\n}\n\n// For some type of series that are not in any coordinate system,\n// like &#39;pie&#39;, &#39;funnel&#39; etc.:\nencode: {\n    value: 3\n}\n</code></pre>\n<p>This is an <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=dataset-encode1&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> for <code class=\"codespan\">encode</code>.</p>\n<p>Specially, in [custom series(~series-custom), some property in <code class=\"codespan\">encode</code>, corresponding to axis, can be set as null to make the series not controlled by the axis, that is, the series data will not be count in the extent of the axis, and the <a href=\"#dataZoom\">dataZoom</a> on the axis will not filter the series.</p>\n<pre><code class=\"lang-js\">var option = {\n    xAxis: {},\n    yAxis: {},\n    dataZoom: [{\n        xAxisIndex: 0\n    }, {\n        yAxisIndex: 0\n    }],\n    series: {\n        type: &#39;custom&#39;,\n        renderItem: function (params, api) {\n            return {\n                type: &#39;circle&#39;,\n                shape: {\n                    cx: 100, // x position is always 100\n                    cy: api.coord([0, api.value(0)])[1],\n                    r: 30\n                },\n                style: {\n                    fill: &#39;blue&#39;\n                }\n            };\n        },\n        encode: {\n            // Then the series will not be controlled\n            // by x axis and corresponding dataZoom.\n            x: -1,\n            y: 1\n        },\n        data: [ ... ]\n    }\n};\n</code></pre>\n"},"seriesLayoutBy":{"type":["string"],"description":"<p>When <a href=\"#dataset\">dataset</a> is used, <code class=\"codespan\">seriesLayoutBy</code> specifies whether the column or the row of <code class=\"codespan\">dataset</code> is mapped to the series, namely, the series is &quot;layout&quot; on columns or rows. Optional values:</p>\n<ul>\n<li>&#39;column&#39;: by default, the columns of <code class=\"codespan\">dataset</code> are mapped the series. In this case, each column represents a dimension.</li>\n<li>&#39;row&#39;：the rows of <code class=\"codespan\">dataset</code> are mapped to the series. In this case, each row represents a dimension.</li>\n</ul>\n<p>Check this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=dataset-series-layout-by\" target=\"_blank\">example</a>.</p>\n","default":"'column'"},"datasetIndex":{"type":["number"],"description":"<p>If <a href=\"#series.data\">series.data</a> is not specified, and <a href=\"#dataset\">dataset</a> exists, the series will use <code class=\"codespan\">dataset</code>. <code class=\"codespan\">datasetIndex</code> specifies which dataset will be used.</p>\n","default":0},"data":{"type":["Array"],"description":"<p>Data array of series, which can be in the following forms:</p>\n<p>Notice, if no <code class=\"codespan\">data</code> specified in series, and there is <a href=\"#dataset\">dataset</a> in option, series will use the first <a href=\"#dataset\">dataset</a> as its datasource. If <code class=\"codespan\">data</code> has been specified, <a href=\"#dataset\">dataset</a> will not used.</p>\n<p><code class=\"codespan\">series.datasetIndex</code> can be used to specify other <a href=\"#dataset\">dataset</a>.</p>\n<p>Basically, data is represented by a two-dimension array, like the example below, where each column is named as a &quot;dimension&quot;.</p>\n<pre><code class=\"lang-js\">series: [{\n    data: [\n        // dimX   dimY   other dimensions ...\n        [  3.4,    4.5,   15,   43],\n        [  4.2,    2.3,   20,   91],\n        [  10.8,   9.5,   30,   18],\n        [  7.2,    8.8,   18,   57]\n    ]\n}]\n</code></pre>\n<ul>\n<li>In <a href=\"#grid\">cartesian (grid)</a>, &quot;dimX&quot; and &quot;dimY&quot; correspond to <a href=\"#xAxis\">xAxis</a> and <a href=\"#yAxis\">yAxis</a> respectively.</li>\n<li>In <a href=\"#polar\">polar</a> &quot;dimX&quot; and &quot;dimY&quot; correspond to <a href=\"#radiusAxis\">radiusAxis</a> 和 <a href=\"#anbleAxis\">angleAxis</a> respectively.</li>\n<li>Other dimensions are optional, which can be used in other places. For example:<ul>\n<li><a href=\"#visualMap\">visualMap</a> can map one or more dimensions to visual (color, symbol size ...).</li>\n<li><a href=\"#series.symbolSize\">series.symbolSize</a> can be set as a callback function, where symbol size can be calculated by values of a certain dimension.</li>\n<li>Values in other dimensions can be shown by <a href=\"#tooltip.formatter\">tooltip.formatter</a> or <a href=\"#series.label.formatter\">series.label.formatter</a>.</li>\n</ul>\n</li>\n</ul>\n<p>Especially, when there is one and only one category axis (axis.type is <code class=\"codespan\">&#39;category&#39;</code>), data can be simply be represented by a one-dimension array, like:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    data: [&#39;a&#39;, &#39;b&#39;, &#39;m&#39;, &#39;n&#39;]\n},\nseries: [{\n    // Each item corresponds to each item in xAxis.data.\n    data: [23,  44,  55,  19]\n    // In fact, it is the simplification of the format below:\n    // data: [[0, 23], [1, 44], [2, 55], [3, 19]]\n}]\n</code></pre>\n<p><br>\n<strong>Relationship between &quot;value&quot; and <a href=\"#xAxis.type\">axis.type</a></strong></p>\n<ul>\n<li><p>When a dimension corresponds to a value axis (axis.type is <code class=\"codespan\">&#39;value&#39;</code> or <code class=\"codespan\">&#39;log&#39;</code>):</p>\n<p>  The value can be a <code class=\"codespan\">number</code> (like <code class=\"codespan\">12</code>) (can also be a number in a <code class=\"codespan\">string</code> format, like <code class=\"codespan\">&#39;12&#39;</code>).</p>\n</li>\n<li><p>When a dimension corresponds to a category axis (axis.type is <code class=\"codespan\">&#39;category&#39;</code>):</p>\n<p>  The value should be the ordinal of the axis.data (based on <code class=\"codespan\">0</code>), the string value of the axis.data. For example:</p>\n<pre><code class=\"lang-js\">  xAxis: {\n      type: &#39;category&#39;,\n      data: [&#39;Monday&#39;, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;]\n  },\n  yAxis: {\n      type: &#39;category&#39;,\n      data: [&#39;a&#39;, &#39;b&#39;, &#39;m&#39;, &#39;n&#39;, &#39;p&#39;, &#39;q&#39;]\n  },\n  series: [{\n      data: [\n          // xAxis      yAxis\n          [  0,           0,    2  ], // This point is located at xAxis: &#39;Monday&#39;, yAxis: &#39;a&#39;.\n          [  &#39;Thursday&#39;,  2,    1  ], // This point is located at xAxis: &#39;Thursday&#39;, yAxis: &#39;m&#39;.\n          [  2,          &#39;p&#39;,   2  ], // This point is located at xAxis: &#39;Wednesday&#39;, yAxis: &#39;p&#39;.\n          [  3,           3,    5  ]\n      ]\n  }]\n</code></pre>\n<p>  There is an example of double category axes: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-punchCard\" target=\"_blank\">Github Punchcard</a>.</p>\n</li>\n<li><p>When a dimension corresponds to a time axis (type is <code class=\"codespan\">&#39;time&#39;</code>), the value can be:</p>\n<ul>\n<li>a timestamp, like <code class=\"codespan\">1484141700832</code>, which represents a UTC time.</li>\n<li>a date string, in one of the formats below:<ul>\n<li>a subset of <a href=\"http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15\" target=\"_blank\">ISO 8601</a>, only including (all of these are treated as local time unless timezone is specified, which is consistent with <a href=\"https://momentjs.com/\" target=\"_blank\">moment</a>):<ul>\n<li>only part of year/month/date/time are specified: <code class=\"codespan\">&#39;2012-03&#39;</code>, <code class=\"codespan\">&#39;2012-03-01&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 05&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 05:06&#39;</code>.</li>\n<li>separated by <code class=\"codespan\">&quot;T&quot;</code> or a space: <code class=\"codespan\">&#39;2012-03-01T12:22:33.123&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 12:22:33.123&#39;</code>.</li>\n<li>timezone specified: <code class=\"codespan\">&#39;2012-03-01T12:22:33Z&#39;</code>, <code class=\"codespan\">&#39;2012-03-01T12:22:33+8000&#39;</code>, <code class=\"codespan\">&#39;2012-03-01T12:22:33-05:00&#39;</code>.</li>\n</ul>\n</li>\n<li>other date string format (all of these are treated as local time):\n<code class=\"codespan\">&#39;2012&#39;</code>, <code class=\"codespan\">&#39;2012-3-1&#39;</code>, <code class=\"codespan\">&#39;2012/3/1&#39;</code>, <code class=\"codespan\">&#39;2012/03/01&#39;</code>,\n<code class=\"codespan\">&#39;2009/6/12 2:00&#39;</code>, <code class=\"codespan\">&#39;2009/6/12 2:05:08&#39;</code>, <code class=\"codespan\">&#39;2009/6/12 2:05:08.123&#39;</code>.</li>\n</ul>\n</li>\n<li>a JavaScript Date instance created by user:<ul>\n<li>Caution, when using a data string to create a Date instance, <a href=\"http://dygraphs.com/date-formats.html\" target=\"_blank\">browser differences and inconsistencies</a> should be considered.</li>\n<li>For example: In chrome, <code class=\"codespan\">new Date(&#39;2012-01-01&#39;)</code> is treated as a Jan 1st 2012 in UTC, while <code class=\"codespan\">new Date(&#39;2012-1-1&#39;)</code> and <code class=\"codespan\">new Date(&#39;2012/01/01&#39;)</code> are treated as Jan 1st 2012 in local timezone. In safari <code class=\"codespan\">new Date(&#39;2012-1-1&#39;)</code> is not supported.</li>\n<li>So if you intent to perform <code class=\"codespan\">new Date(dateString)</code>, it is strongly recommended to use a time parse library (e.g., <a href=\"https://momentjs.com/\" target=\"_blank\">moment</a>), or use <code class=\"codespan\">echarts.number.parseDate</code>, or check <a href=\"http://dygraphs.com/date-formats.html\" target=\"_blank\">this</a>.</li>\n</ul>\n</li>\n</ul>\n</li>\n</ul>\n<p><br>\n<strong>Customize a data item:</strong></p>\n<p>When needing to customize a data item, it can be set as an object, where property <code class=\"codespan\">value</code> reprensent real value. For example:</p>\n<pre><code class=\"lang-js\">[\n    12,\n    24,\n    {\n        value: [24, 32],\n        // label style, only works in this data item.\n        label: {},\n        // item style, only works in this data item.\n        itemStyle:{}\n    },\n    33\n]\n// Or\n[\n    [12, 332],\n    [24, 32],\n    {\n        value: [24, 32],\n        // label style, only works in this data item.\n        label: {},\n        // item style, only works in this data item.\n        itemStyle:{}\n    },\n    [33, 31]\n]\n</code></pre>\n<p><br>\n<strong>Empty value:</strong></p>\n<p><code class=\"codespan\">&#39;-&#39;</code> or <code class=\"codespan\">null</code> or <code class=\"codespan\">undefined</code> or <code class=\"codespan\">NaN</code> can be used to describe that a data item does not exist (ps：<em>not exist</em> does not means its value is <code class=\"codespan\">0</code>).</p>\n<p>For example, line chart can break when encounter an empty value, and scatter chart do not display graphic elements for empty values.</p>\n<p><br><br></p>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>The name of data item.</p>\n"},"value":{"type":["number"],"description":"<p>The value of a single data item.</p>\n"},"label":{"type":["Object"],"description":"<p>Label style configurations of single data.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Rectangle style configurations of single data.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Bar color. </p>\n","uiControl":{"type":"color"},"default":"auto"},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color of bar.</p>\n","uiControl":{"type":"color","value":"#000"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of bar. defaults to have no border.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type. Can be <code class=\"codespan\">&#39;dashed&#39;</code>, <code class=\"codespan\">&#39;dotted&#39;</code>.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>The radius of rounded corner. Its unit is px. And it supports use array to respectively specify the 4 corner radiuses.</p>\n<p>For example:</p>\n<pre><code>borderRadius: 5, // consistently set the size of 4 rounded corners\nborderRadius: [5, 5, 0, 0] // (clockwise upper left, upper right, bottom right and bottom left)\n</code></pre>","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"},"default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of single data.</p>\n","properties":{"label":{"type":["Object"],"description":"<p>Label style configurations of single data.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Rectangle style configurations of single data.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Bar color. </p>\n","uiControl":{"type":"color"},"default":"auto"},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color of bar.</p>\n","uiControl":{"type":"color","value":"#000"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of bar. defaults to have no border.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type. Can be <code class=\"codespan\">&#39;dashed&#39;</code>, <code class=\"codespan\">&#39;dotted&#39;</code>.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>The radius of rounded corner. Its unit is px. And it supports use array to respectively specify the 4 corner radiuses.</p>\n<p>For example:</p>\n<pre><code>borderRadius: 5, // consistently set the size of 4 rounded corners\nborderRadius: [5, 5, 0, 0] // (clockwise upper left, upper right, bottom right and bottom left)\n</code></pre>","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"},"default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state of single data.</p>\n","properties":{"label":{"type":["Object"],"description":"<p>Label style configurations of single data.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Rectangle style configurations of single data.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Bar color. </p>\n","uiControl":{"type":"color"},"default":"auto"},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color of bar.</p>\n","uiControl":{"type":"color","value":"#000"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of bar. defaults to have no border.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type. Can be <code class=\"codespan\">&#39;dashed&#39;</code>, <code class=\"codespan\">&#39;dotted&#39;</code>.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>The radius of rounded corner. Its unit is px. And it supports use array to respectively specify the 4 corner radiuses.</p>\n<p>For example:</p>\n<pre><code>borderRadius: 5, // consistently set the size of 4 rounded corners\nborderRadius: [5, 5, 0, 0] // (clockwise upper left, upper right, bottom right and bottom left)\n</code></pre>","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"},"default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state of single data.</p>\n","properties":{"label":{"type":["Object"],"description":"<p>Label style configurations of single data.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Rectangle style configurations of single data.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Bar color. </p>\n","uiControl":{"type":"color"},"default":"auto"},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color of bar.</p>\n","uiControl":{"type":"color","value":"#000"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of bar. defaults to have no border.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type. Can be <code class=\"codespan\">&#39;dashed&#39;</code>, <code class=\"codespan\">&#39;dotted&#39;</code>.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>The radius of rounded corner. Its unit is px. And it supports use array to respectively specify the 4 corner radiuses.</p>\n<p>For example:</p>\n<pre><code>borderRadius: 5, // consistently set the size of 4 rounded corners\nborderRadius: [5, 5, 0, 0] // (clockwise upper left, upper right, bottom right and bottom left)\n</code></pre>","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"},"default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}}},"clip":{"type":["boolean"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v4.4.0</code></p>\n</blockquote>\n<p>If clip the overflow on the coordinate system. Clip results varies between series:</p>\n<ul>\n<li>Scatter：Ignore the symbols exceeds the coordinate system. Not clip the elements.</li>\n<li>Bar：Clip all the overflowed. With bar width kept.</li>\n<li>Line：Clip the overflowed line.</li>\n<li>Lines: Clip all the overflowed.</li>\n<li>Candlestick: Ignore the elements exceeds the coordinate system.</li>\n<li>Custom: Clip all the olverflowed.</li>\n</ul>\n<p>All these series have default value <code class=\"codespan\">true</code> except custom series. Set it to <code class=\"codespan\">false</code> if you don&#39;t want to clip.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in Bar chart .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in Bar chart , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p><strong>pie chart</strong></p>\n<p>The pie chart is mainly used for showing proportion of different categories. Each arc length represents the proportion of data quantity.</p>\n<p><strong>Tip:</strong> The pie chart is more suitable for illustrating the numerical proportion. If you just to present the numerical differences of various categories, the <a href=\"bar\" target=\"_blank\">bar graph</a> chart is more suggested. Because compared to tiny length difference,  people is less sensitive to the minor radian difference. Otherwise, it can also be shown as Nightingale chart by using the <a href=\"#series-pie.roseType\">roseType</a> to distinguish different data through radius.</p>\n<p>Since ECharts v4.6.0, we provide <code class=\"codespan\">&#39;labelLine&#39;</code> and <code class=\"codespan\">&#39;edge&#39;</code> two extra layouts. Check <a href=\"#series-pie.label.alignTo\">label.alignTo</a> for more information.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=pie-alignTo&reset=1&edit=1\" width=\"900\" height=\"250\"></iframe>\n\n\n<p>For multiple pie series in a single chart, you may use <a href=\"#series-pie.left\">left</a>, <a href=\"#series-pie.right\">right</a>, <a href=\"#series-pie.top\">top</a>, <a href=\"#series-pie.bottom\">bottom</a>, <a href=\"#series-pie.width\">width</a>, and <a href=\"#series-pie.height\">height</a> to locate the pies. Percetage values like <a href=\"#series-pie.radius\">radius</a> or <a href=\"#series-pie.label.edgeDistance\">label.edgeDistance</a> are relative to the viewport defined by this setting.</p>\n<p><strong> The below example shows a customized Nightingale chart: </strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=pie-custom&edit=1&reset=1\" width=\"500\" height=\"400\"></iframe>\n\n","properties":{"type":{"type":["string"],"description":"","default":"'pie'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"legendHoverLink":{"type":["boolean"],"description":"\n\n<p>Whether to enable highlighting chart when <a href=\"#legend\">legend</a> is being hovered.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"selectedMode":{"type":["boolean","string"],"description":"\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"selectedOffset":{"type":["number"],"description":"\n\n<p>The offset distance of selected sector.</p>\n","uiControl":{"type":"number","min":"0","default":"10"},"default":10},"clockwise":{"type":["boolean"],"description":"\n\n<p>Whether the layout of sectors of pie chart is clockwise.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"startAngle":{"type":["number"],"description":"\n\n<p>The start angle, which range is [0, 360].</p>\n","uiControl":{"type":"angle","step":"1","min":"0","max":"360","default":"90"},"default":90},"minAngle":{"type":["number"],"description":"\n\n<p>The minimum angle of sector (0 ~ 360). It prevents some sector from being too small when value is small, which will affect user interaction.</p>\n","uiControl":{"type":"angle","step":"1","min":"0","max":"360","default":"0"},"default":0},"minShowLabelAngle":{"type":["number"],"description":"\n\n<p>If a sector is less than this angle (0 ~ 360), label and labelLine will not be displayed.</p>\n","uiControl":{"type":"angle","step":"1","min":"0","max":"360","default":"0"},"default":0},"roseType":{"type":["boolean","string"],"description":"\n\n<p>Whether to show as Nightingale chart, which distinguishs data through radius. There are 2 optional modes:</p>\n<ul>\n<li><code class=\"codespan\">&#39;radius&#39;</code> Use central angle to show the percentage of data, radius to show data size.</li>\n<li><code class=\"codespan\">&#39;area&#39;</code> All the sectors will share the same central angle, the data size is shown only through radiuses.</li>\n</ul>\n","uiControl":{"type":"enum","options":"radius,area"},"default":false},"avoidLabelOverlap":{"type":["boolean"],"description":"\n\n<p>Whether to enable the strategy to avoid labels overlap. Defaults to be enabled, which will move the label positions in the case of labels overlapping</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"stillShowZeroSum":{"type":["boolean"],"description":"\n\n<p>Whether to show sector when all data are zero.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between pie chart component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":0},"top":{"type":["string","number"],"description":"<p>Distance between pie chart component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":0},"right":{"type":["string","number"],"description":"<p>Distance between pie chart component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":0},"bottom":{"type":["string","number"],"description":"<p>Distance between pie chart component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":0},"width":{"type":["string","number"],"description":"<p>Width of pie chart component. Adaptive by default.</p>\n","default":"'auto'"},"height":{"type":["string","number"],"description":"<p>Height of pie chart component. Adaptive by default.</p>\n","default":"'auto'"},"label":{"type":["Object"],"description":"<p>Text label of pie chart, to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"","default":false},"position":{"type":["string"],"description":"<p>The position of label.</p>\n<p><strong>Options: </strong></p>\n<ul>\n<li><p><code class=\"codespan\">&#39;outside&#39;</code></p>\n<p>  Outside of sectors of pie chart, which relates to corresponding sector through <a href=\"#series-pie.labelLine\">visual guide line</a>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p>  Inside the sectors of pie chart.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;inner&#39;</code> is the same with <code class=\"codespan\">&#39;inside&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;center&#39;</code></p>\n<p>  In the center of pie chart. See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=pie-doughnut\" target=\"_blank\">pie-doughnut example</a></p>\n</li>\n</ul>\n","default":"'outside'"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // percentage\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"rotate":{"type":["boolean","number"],"description":"<p>Label rotation.</p>\n<ul>\n<li>If <code class=\"codespan\">true</code>, layout label radically.</li>\n<li>If <code class=\"codespan\">number</code>, means degree that labels are rotated. From -90 degree to 90 degree. The negative value represents clockwise.</li>\n</ul>\n","default":null},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}},"alignTo":{"type":["string"],"description":"\n\n<p>Label aligning policy. Valid only when <code class=\"codespan\">position</code> is <code class=\"codespan\">&#39;outer&#39;</code>.</p>\n<p>Since ECharts v4.6.0, we provide <code class=\"codespan\">&#39;labelLine&#39;</code> and <code class=\"codespan\">&#39;edge&#39;</code> two extra valid <code class=\"codespan\">alignTo</code> values.</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> (default): label lines have fixed length as <a href=\"#series-pie.labelLine.length\">labelLine.length</a> and <a href=\"#series-pie.labelLine.length2\">labelLine.length2</a>.</li>\n<li><code class=\"codespan\">&#39;labelLine&#39;</code>: aligning to the end of label lines and the length of the shortest horizontal label lines is configured by <a href=\"#series-pie.labelLine.length2\">labelLine.length2</a>.</li>\n<li><code class=\"codespan\">&#39;edge&#39;</code>: aligning to text and the distance between the edges of text and the viewport is configured by <a href=\"#series-pie.label.edgeDistance\">label.edgeDistance</a>.</li>\n</ul>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=pie-alignTo&reset=1&edit=1\" width=\"900\" height=\"250\"></iframe>\n\n","uiControl":{"type":"enum","options":"labelLine,edge"},"default":"'none'"},"edgeDistance":{"type":["string","number"],"description":"\n\n<p>The horizontal distance between text edges and viewport when <a href=\"#series-pie.label.position\">label.position</a> is <code class=\"codespan\">&#39;outer&#39;</code> and <a href=\"#series-pie.label.alignTo\">label.alignTo</a> is <code class=\"codespan\">&#39;edge&#39;</code>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pie-label-margin&edit=1&reset=1\" width=\"900\" height=\"250\"></iframe>\n\n\n<p>In most cases, you need a small <code class=\"codespan\">edgeDistance</code> value like <code class=\"codespan\">10</code> for mobile devices to make sure more text can be shown instead of being <code class=\"codespan\">...</code>. But on larger resolutions, a percentage value should be applied so that the label lines won&#39;t be too long. If your chart is used in varied resolutions, it is advised to set <a href=\"tutorial.html#Responsive%20Mobile-End\" target=\"_blank\">responsive design</a> for different resolutions.</p>\n","uiControl":{"type":"percent","default":"20%"},"default":"'25%'"},"bleedMargin":{"type":["number"],"description":"\n\n<p>The horizontal distance between text and viewport when <a href=\"#series-pie.label.position\">label.position</a> is <code class=\"codespan\">&#39;outer&#39;</code> and <a href=\"#series-pie.label.alignTo\">label.alignTo</a> is <code class=\"codespan\">&#39;none&#39;</code> or <code class=\"codespan\">&#39;labelLine&#39;</code>. Longer text will be truncated into <code class=\"codespan\">&#39;...&#39;</code>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pie-label-bleedMargin&edit=1&reset=1\" width=\"800\" height=\"250\"></iframe>\n\n","uiControl":{"type":"number","default":"10","min":"0","step":"1"},"default":10},"distanceToLabelLine":{"type":["number"],"description":"\n\n<p>Distance between label line and text.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pie-label-distanceToLabelLine&edit=1&reset=1\" width=\"800\" height=\"250\"></iframe>\n\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5}}},"labelLine":{"type":["Object"],"description":"<p>The style of visual guide line. Will show when <a href=\"#series-pie.label.position\">label position</a> is set as <code class=\"codespan\">&#39;outside&#39;</code>.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length":{"type":["number"],"description":"\n\n<p>The length of the first segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":90},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"maxSurfaceAngle":{"type":["number"],"description":"<p>Max angle between guide line and surface normal. To prevent guide line overlapping with sector.</p>\n<p>Can be 0 - 180 degree.</p>\n"}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of , <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"color":{"type":["Color","Function"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n<p>Supports callback functions, in the form of:</p>\n<pre><code class=\"lang-js\">(params: Object) =&gt; Color\n</code></pre>\n<p>Input parameters are <code class=\"codespan\">seriesIndex</code>, <code class=\"codespan\">dataIndex</code>, <code class=\"codespan\">data</code>, <code class=\"codespan\">value</code>, and etc. of data item.</p>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"emphasis":{"type":["Object"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"scale":{"type":["boolean"],"description":"\n\n<p>Whether to scale to highlight the data in emphasis state.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"scaleSize":{"type":["number"],"description":"\n\n<p>Size of scale. Available when <a href=\"#series-pie.emphasis.scale\">emphasis.scale</a> is set <code class=\"codespan\">true</code>.</p>\n","uiControl":{"type":"number","min":"0","default":"10"},"default":10},"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"","default":false},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // percentage\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"rotate":{"type":["boolean","number"],"description":"<p>Label rotation.</p>\n<ul>\n<li>If <code class=\"codespan\">true</code>, layout label radically.</li>\n<li>If <code class=\"codespan\">number</code>, means degree that labels are rotated. From -90 degree to 90 degree. The negative value represents clockwise.</li>\n</ul>\n","default":null},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":""},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Available when <a href=\"#series-pie.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"","default":false},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // percentage\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"rotate":{"type":["boolean","number"],"description":"<p>Label rotation.</p>\n<ul>\n<li>If <code class=\"codespan\">true</code>, layout label radically.</li>\n<li>If <code class=\"codespan\">number</code>, means degree that labels are rotated. From -90 degree to 90 degree. The negative value represents clockwise.</li>\n</ul>\n","default":null},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":""},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of select state. Available when <a href=\"#series-pie.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"","default":false},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // percentage\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"rotate":{"type":["boolean","number"],"description":"<p>Label rotation.</p>\n<ul>\n<li>If <code class=\"codespan\">true</code>, layout label radically.</li>\n<li>If <code class=\"codespan\">number</code>, means degree that labels are rotated. From -90 degree to 90 degree. The negative value represents clockwise.</li>\n</ul>\n","default":null},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":""},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"center":{"type":["Array"],"description":"\n\n<p>Center position of Pie chart, the first of which is the horizontal position, and the second is the vertical position.</p>\n<p>Percentage is supported. When set in percentage, the item is relative to the container width, and the second item to the height.</p>\n<p><strong>Example: </strong></p>\n<pre><code>// Set to absolute pixel values\ncenter: [400, 300]\n// Set to relative percent\ncenter: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>","uiControl":{"type":"percentvector","dims":"x,y"},"default":"['50%', '50%']"},"radius":{"type":["number","string","Array"],"description":"\n\n<p>Radius of Pie chart. Value can be:</p>\n<ul>\n<li><code class=\"codespan\">number</code>: Specify outside radius directly.</li>\n<li><code class=\"codespan\">string</code>: For example, <code class=\"codespan\">&#39;20%&#39;</code>, means that the outside radius is 20% of the viewport size (the little one between width and height of the chart container).</li>\n</ul>\n<ul>\n<li><code class=\"codespan\">Array.&lt;number|string&gt;</code>: The first item specifies the inside radius, and the second item specifies the outside radius. Each item follows the definitions above.</li>\n</ul>\n<p>Donut chart can be achieved by setting a inner radius.</p>\n","uiControl":{"type":"percentvector","dims":"inner,outer","default":"0%, 75%"},"default":"[0, '75%']"},"seriesLayoutBy":{"type":["string"],"description":"<p>When <a href=\"#dataset\">dataset</a> is used, <code class=\"codespan\">seriesLayoutBy</code> specifies whether the column or the row of <code class=\"codespan\">dataset</code> is mapped to the series, namely, the series is &quot;layout&quot; on columns or rows. Optional values:</p>\n<ul>\n<li>&#39;column&#39;: by default, the columns of <code class=\"codespan\">dataset</code> are mapped the series. In this case, each column represents a dimension.</li>\n<li>&#39;row&#39;：the rows of <code class=\"codespan\">dataset</code> are mapped to the series. In this case, each row represents a dimension.</li>\n</ul>\n<p>Check this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=dataset-series-layout-by\" target=\"_blank\">example</a>.</p>\n","default":"'column'"},"datasetIndex":{"type":["number"],"description":"<p>If <a href=\"#series.data\">series.data</a> is not specified, and <a href=\"#dataset\">dataset</a> exists, the series will use <code class=\"codespan\">dataset</code>. <code class=\"codespan\">datasetIndex</code> specifies which dataset will be used.</p>\n","default":0},"dimensions":{"type":["Array"],"description":"<p><code class=\"codespan\">dimensions</code> can be used to define dimension info for <code class=\"codespan\">series.data</code> or <code class=\"codespan\">dataset.source</code>.</p>\n<p>Notice: if <a href=\"#dataset\">dataset</a> is used, we can definite dimensions in <a href=\"#dataset.dimensions\">dataset.dimensions</a>, or provide dimension names in the first column/row of <a href=\"#dataset.source\">dataset.source</a>, and not need to specify <code class=\"codespan\">dimensions</code> here. But if <code class=\"codespan\">dimensions</code> is specified here, it will be used despite the dimension definitions in dataset.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // &#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        // Specify name for each dimesions, which will be displayed in tooltip.\n        dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [\n        null,                // If you do not intent to defined this dimension, use null is fine.\n        {type: &#39;ordinal&#39;},   // Specify type of this dimension.\n                             // &#39;ordinal&#39; is always used in string.\n                             // If type is not specified, echarts will guess type by data.\n        {name: &#39;good&#39;, type: &#39;number&#39;},\n        &#39;bad&#39;                // Equals to {name: &#39;bad&#39;}.\n    ]\n}\n</code></pre>\n<p>Each data item of <code class=\"codespan\">dimensions</code> can be:</p>\n<ul>\n<li><code class=\"codespan\">string</code>, for example, <code class=\"codespan\">&#39;someName&#39;</code>, which equals to <code class=\"codespan\">{name: &#39;someName&#39;}</code>.</li>\n<li><code class=\"codespan\">Object</code>, where the attributes can be:<ul>\n<li>name: <code class=\"codespan\">string</code>.</li>\n<li>type: <code class=\"codespan\">string</code>, supports:<ul>\n<li><code class=\"codespan\">number</code></li>\n<li><code class=\"codespan\">float</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array\" target=\"_blank\">Float64Array</a></li>\n<li><code class=\"codespan\">int</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array\" target=\"_blank\">Int32Array</a></li>\n<li><code class=\"codespan\">ordinal</code>, discrete value, which represents string generally.</li>\n<li><code class=\"codespan\">time</code>, time value, see <a href=\"#series.data\">data</a> to check the format of time value.</li>\n</ul>\n</li>\n<li>displayName: <code class=\"codespan\">string</code>, generally used in tooltip for dimension display. If not specified, use <code class=\"codespan\">name</code> by default.</li>\n</ul>\n</li>\n</ul>\n<p>When <code class=\"codespan\">dimensions</code> is specified, the default <code class=\"codespan\">tooltip</code> will be displayed vertically, which is better to show diemsion names. Otherwise, <code class=\"codespan\">tooltip</code> will displayed only value horizontally.</p>\n"},"encode":{"type":["Object"],"description":"<p>Define what is encoded to for each dimension of <code class=\"codespan\">data</code>. For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // Each column is called a dimension.\n            // There are five dimensions: 0, 1, 2, 3, 4.\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        encode: {\n            x: [3, 1, 5],      // Dimension 3, 1, 5 is mapped to x axis.\n            y: 2,              // Dimension 2 is mapped to y axis.\n            tooltip: [3, 2, 4] // Dimension 3, 2, 4 will be displayed in tooltip.\n        }\n    }\n}\n</code></pre>\n<p>When <a href=\"#series.dimensions\">dimensions</a> is used to defined name for a certain dimension, <code class=\"codespan\">encode</code> can refer the name directly. For example:</p>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;],\n    encode: {\n        x: &#39;date&#39;,\n        y: [&#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<p>The basic structure of <a href=\"option.html#series.encode\" target=\"_blank\">encode</a> is illustrated as follows, where the left part of colon is the name of axis like <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code> or some special reserved names like &quot;tooltip&quot;, &quot;itemName&quot; etc., and the right part of the colon is the dimension names or dimension indices (based on 0). One or more dimensions can be specified. Usually not all of mappings need to be specified, only specify needed ones.</p>\n<p>The properties available in <code class=\"codespan\">encode</code> listed as follows:</p>\n<pre><code class=\"lang-js\">// In any of the series and coordinate systems,\n// these properties are available:\nencode: {\n    // Display dimension &quot;product&quot; and &quot;score&quot; in the tooltip.\n    tooltip: [&#39;product&#39;, &#39;score&#39;]\n    // Set the series name as the concat of the names of dimensions[1] and dimensions[3].\n    // (sometimes the dimension names are too long to type in series.name manually).\n    seriesName: [1, 3],\n    // Using dimensions[2] as the id of each data item. This is useful when dynamically\n    // update data by `chart.setOption()`, where the new and old data item can be\n    // corresponded by id, by which the appropriate animation can be performed when updating.\n    itemId: 2,\n    // Using dimensions[3] as the name of each data item. This is useful in charts like\n    // &#39;pie&#39;, &#39;funnel&#39;, where data item name can be displayed in legend.\n    itemName: 3\n}\n\n// These properties only work in cartesian(grid) coordinate system:\nencode: {\n    // Map dimensions[1], dimensions[5] and dimension &quot;score&quot; to the X axis.\n    x: [1, 5, &#39;score&#39;],\n    // Map dimensions[0] to the Y axis.\n    y: 0\n}\n\n// These properties only work in polar coordinate system:\nencode: {\n    radius: 3,\n    angle: 2,\n    ...\n}\n\n// These properties only work in geo coordinate system:\nencode: {\n    lng: 3,\n    lat: 2\n}\n\n// For some type of series that are not in any coordinate system,\n// like &#39;pie&#39;, &#39;funnel&#39; etc.:\nencode: {\n    value: 3\n}\n</code></pre>\n<p>This is an <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=dataset-encode1&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> for <code class=\"codespan\">encode</code>.</p>\n<p>Specially, in [custom series(~series-custom), some property in <code class=\"codespan\">encode</code>, corresponding to axis, can be set as null to make the series not controlled by the axis, that is, the series data will not be count in the extent of the axis, and the <a href=\"#dataZoom\">dataZoom</a> on the axis will not filter the series.</p>\n<pre><code class=\"lang-js\">var option = {\n    xAxis: {},\n    yAxis: {},\n    dataZoom: [{\n        xAxisIndex: 0\n    }, {\n        yAxisIndex: 0\n    }],\n    series: {\n        type: &#39;custom&#39;,\n        renderItem: function (params, api) {\n            return {\n                type: &#39;circle&#39;,\n                shape: {\n                    cx: 100, // x position is always 100\n                    cy: api.coord([0, api.value(0)])[1],\n                    r: 30\n                },\n                style: {\n                    fill: &#39;blue&#39;\n                }\n            };\n        },\n        encode: {\n            // Then the series will not be controlled\n            // by x axis and corresponding dataZoom.\n            x: -1,\n            y: 1\n        },\n        data: [ ... ]\n    }\n};\n</code></pre>\n"},"data":{"type":["Array"],"description":"<p>Data array of  series, which can be a single data value, like:</p>\n<pre><code class=\"lang-js\">[12, 34, 56, 10, 23]\n</code></pre>\n<p>Or, if need extra dimensions for components like <a href=\"#visualMap\">visualMap</a> to map to graphic attributes like color, it can also be in the form of array. For example:</p>\n<pre><code class=\"lang-js\">[[12, 14], [34, 50], [56, 30], [10, 15], [23, 10]]\n</code></pre>\n<p>In this case, we can assgin the second value in each array item to <a href=\"#visualMap\">visualMap</a> component.</p>\n<p>More likely, we need to assign name to each data item, in which case each item should be an object:</p>\n<pre><code class=\"lang-js\">[{\n    // name of date item\n    name: &#39;data1&#39;,\n    // value of date item is 8\n    value: 10\n}, {\n    name: &#39;data2&#39;,\n    value: 20\n}]\n</code></pre>\n<p>Each data item can be further customized:</p>\n<pre><code class=\"lang-js\">[{\n    name: &#39;data1&#39;,\n    value: 10\n}, {\n    // name of data item\n    name: &#39;data2&#39;,\n    value : 56,\n    // user-defined label format that only useful for this data item\n    label: {},\n    // user-defined special itemStyle that only useful for this data item\n    itemStyle:{}\n}]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>The name of data item.</p>\n"},"value":{"type":["number"],"description":"<p>Data value.</p>\n"},"selected":{"type":["boolean"],"description":"<p>Whether the data item is selected.</p>\n","default":false},"label":{"type":["Object"],"description":"<p>The label configuration of a single sector.</p>\n","properties":{"show":{"type":["boolean"],"description":"","default":false},"position":{"type":["string"],"description":"<p>The position of label.</p>\n<p><strong>Options: </strong></p>\n<ul>\n<li><p><code class=\"codespan\">&#39;outside&#39;</code></p>\n<p>  Outside of sectors of pie chart, which relates to corresponding sector through <a href=\"#series-pie.labelLine\">visual guide line</a>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p>  Inside the sectors of pie chart.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;inner&#39;</code> is the same with <code class=\"codespan\">&#39;inside&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;center&#39;</code></p>\n<p>  In the center of pie chart. See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=pie-doughnut\" target=\"_blank\">pie-doughnut example</a></p>\n</li>\n</ul>\n","default":"'outside'"},"rotate":{"type":["boolean","number"],"description":"<p>Label rotation.</p>\n<ul>\n<li>If <code class=\"codespan\">true</code>, layout label radically.</li>\n<li>If <code class=\"codespan\">number</code>, means degree that labels are rotated. From -90 degree to 90 degree. The negative value represents clockwise.</li>\n</ul>\n","default":null},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":""},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of , <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"","default":false},"rotate":{"type":["boolean","number"],"description":"<p>Label rotation.</p>\n<ul>\n<li>If <code class=\"codespan\">true</code>, layout label radically.</li>\n<li>If <code class=\"codespan\">number</code>, means degree that labels are rotated. From -90 degree to 90 degree. The negative value represents clockwise.</li>\n</ul>\n","default":null},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":""},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"","default":false},"rotate":{"type":["boolean","number"],"description":"<p>Label rotation.</p>\n<ul>\n<li>If <code class=\"codespan\">true</code>, layout label radically.</li>\n<li>If <code class=\"codespan\">number</code>, means degree that labels are rotated. From -90 degree to 90 degree. The negative value represents clockwise.</li>\n</ul>\n","default":null},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":""},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"","default":false},"rotate":{"type":["boolean","number"],"description":"<p>Label rotation.</p>\n<ul>\n<li>If <code class=\"codespan\">true</code>, layout label radically.</li>\n<li>If <code class=\"codespan\">number</code>, means degree that labels are rotated. From -90 degree to 90 degree. The negative value represents clockwise.</li>\n</ul>\n","default":null},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":""},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series data.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}}},"markPoint":{"type":["Object"],"description":"<p>Mark point in a chart.</p>\n","properties":{"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-pie.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'pin'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-pie.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":50},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-pie.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label of mark point.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark point.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Data array for mark points, each of which is an object. Here are some ways to assign mark point position.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-pie.markPoint.data.x\">x</a>, <a href=\"#series-pie.markPoint.data.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p><strong>For example: </strong></p>\n<pre><code class=\"lang-js\">data: [\n\n    {\n        name: &#39;screen coordinate&#39;,\n        x: 100,\n        y: 100\n    }\n]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Mark point name.</p>\n","default":"''"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markLine":{"type":["Object"],"description":"<p>Use a line in the chart to illustrate.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"symbol":{"type":["string","Array"],"description":"<p>Symbol type at the two ends of the mark line. It can be an array for two ends, or assigned seperately. See <a href=\"#series-pie.markLine.data.0.symbol\">data.symbol</a> for more format information.</p>\n"},"symbolSize":{"type":["number","Array"],"description":"<p>Symbol size at the two ends of the mark line. It can be an array for two ends, or assigned seperately.</p>\n<p><strong>Attention: </strong> You cannot assgin width and height seperately as normal <code class=\"codespan\">symbolSize</code>.</p>\n"},"precision":{"type":["number"],"description":"<p>Precision of marking line value, which is useful when displaying average value mark line.</p>\n","default":2},"label":{"type":["Object"],"description":"<p>Mark line text.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"<p>Mark line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark line.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>Data array of marking line. Every array item can be an array of one or two values, representing starting and ending point of the line, and every item is an object. Here are several ways to assign the positions of starting and ending point.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-pie.markLine.data.0.x\">x</a>, <a href=\"#series-pie.markLine.data.0.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<pre><code>data: [\n\n[\n        {\n            name: &#39;Mark line between two points&#39;,\n            x: 100,\n            y: 100\n        },\n        {\n            x: 500,\n            y: 200\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Data of the starting point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'starting point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of starting point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>starting point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of starting point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of starting point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Data of the ending point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'ending point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of ending point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>ending point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of ending point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of ending point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markArea":{"type":["Object"],"description":"<p>Used to mark an area in chart. For example, mark a time interval.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label in mark area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Style of the mark area.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark area.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>The scope of the area is defined by <code class=\"codespan\">data</code>, which is an array with two item, representing the left-top point and the right-bottom point of rectangle area. Each item can be defined as follows:</p>\n<ol>\n<li>Specify the coordinate in screen coordinate system using <a href=\"#series-pie.markArea.data.0.x\">x</a>, <a href=\"#series-pie.markArea.data.0.y\">y</a>, where the unit is pixel (e.g., the value is <code class=\"codespan\">5</code>), or percent (e.g., the value is <code class=\"codespan\">&#39;35%&#39;</code>).</li>\n</ol>\n<p>The priority follows as above if more than one above definition used.</p>\n<pre><code>data: [\n\n[\n        {\n            name: &#39;Mark area in two screen points&#39;,\n            x: 100,\n            y: 100\n        }, {\n            x: &#39;90%&#39;,\n            y: &#39;10%&#39;\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Specify the left-top point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'start'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Specify the right-bottom point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'end'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"false","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animationType":{"type":["string"],"description":"\n\n<p>Initial animation type.</p>\n<ul>\n<li><code class=\"codespan\">&#39;expansion&#39;</code> Default expansion animation.</li>\n<li><code class=\"codespan\">&#39;scale&#39;</code> Scale animation. You can use it with <code class=\"codespan\">animationEasing=&#39;elasticOut&#39;</code> to have popup effect.</li>\n</ul>\n","uiControl":{"type":"enum","options":"expansion,scale"},"default":"'expansion'"},"animationTypeUpdate":{"type":["string"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v4.4.0</code></p>\n</blockquote>\n<p>Animation type when data updates.</p>\n<ul>\n<li><code class=\"codespan\">&#39;transition&#39;</code> Changing start and end angle of each sector from the old value to new value.</li>\n<li><code class=\"codespan\">&#39;expansion&#39;</code> The whole pie expands again.</li>\n</ul>\n","uiControl":{"type":"enum","options":"expansion,transition"},"default":"'transition'"},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p>Scatter (bubble) chart . The scatter chart in <a href=\"#grid\">rectangular coordinate</a> could be used to present the relation between  <code class=\"codespan\">x</code> and <code class=\"codespan\">y</code>. If data have multiple dimensions, the values of the other dimensions can be visualized through <a href=\"#series-scatter.symbol\">symbol</a> with various sizes and colors, which becomes a bubble chart. These can be done by using with <a href=\"#visualMap\">visualMap</a> component.</p>\n<p>It could be used with <a href=\"#grid\">rectangular coordinate</a> and <a href=\"#polar\">polar coordinate</a> and <a href=\"#geo\">geographical coordinate</a>.</p>\n","properties":{"type":{"type":["string"],"description":"","default":"'scatter'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"coordinateSystem":{"type":["string"],"description":"<p>The coordinate used in the series, whose options are:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;cartesian2d&#39;</code></p>\n<p>  Use a two-dimensional rectangular coordinate (also known as Cartesian coordinate), with <a href=\"#series-bar.xAxisIndex\">xAxisIndex</a> and <a href=\"#series-bar.yAxisIndex\">yAxisIndex</a> to assign the corresponding axis component.</p>\n</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;polar&#39;</code></p>\n<p>  Use polar coordinates, with <a href=\"#series-bar.polarIndex\">polarIndex</a> to assign the corresponding polar coordinate component.</p>\n</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;geo&#39;</code></p>\n<p>  Use geographic coordinate, with <a href=\"#series-bar.geoIndex\">geoIndex</a> to assign the corresponding geographic coordinate components.</p>\n</li>\n</ul>\n","default":"'cartesian2d'"},"xAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#xAxis\">x axis</a> to combine with, which is  useful for multiple x axes in one chart.</p>\n","default":0},"yAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#yAxis\">y axis</a> to combine with, which is  useful for multiple y axes in one chart.</p>\n","default":0},"polarIndex":{"type":["number"],"description":"<p>Index of <a href=\"#polar\">polar coordinate</a> to combine with, which is useful for multiple polar axes in one chart.</p>\n","default":0},"geoIndex":{"type":["number"],"description":"<p>Index of <a href=\"#geo\">geographic coordinate</a> to combine with, which is useful for multiple geographic axes in one chart.</p>\n","default":0},"calendarIndex":{"type":["number"],"description":"<p>Index of <a href=\"#calendar\">calendar coordinates</a> to combine with, which is useful for multiple calendar coordinates in one chart.</p>\n","default":0},"legendHoverLink":{"type":["boolean"],"description":"\n\n<p>Whether to enable highlighting chart when <a href=\"#legend\">legend</a> is being hovered.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-scatter.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'circle'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-scatter.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":10},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-scatter.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"large":{"type":["boolean"],"description":"\n\n<p>Whether to enable the optimization of large-scale data. It could be set when large data causes performance problem.</p>\n<p>After being enabled, <code class=\"codespan\">largeThreshold</code> can be used to indicate the minimum number for turning on the optimization.</p>\n<p>But when the optimization enabled, the style of single data item can&#39;t be customized any more.</p>\n","uiControl":{"type":"boolean"},"default":false},"largeThreshold":{"type":["number"],"description":"\n\n<p>The threshold enabling the drawing optimization.</p>\n","uiControl":{"type":"number","min":"1","default":"2000"},"default":2000},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"label":{"type":["Object"],"description":"<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of , <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"color":{"type":["Color","Function"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n<p>Supports callback functions, in the form of:</p>\n<pre><code class=\"lang-js\">(params: Object) =&gt; Color\n</code></pre>\n<p>Input parameters are <code class=\"codespan\">seriesIndex</code>, <code class=\"codespan\">dataIndex</code>, <code class=\"codespan\">data</code>, <code class=\"codespan\">value</code>, and etc. of data item.</p>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"0.8","min":"0","max":"1","step":"0.01"},"default":0.8}}},"emphasis":{"type":["Object"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"scale":{"type":["boolean"],"description":"\n\n<p>Whether to scale to highlight the data in emphasis state.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Available when <a href=\"#series-scatter.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of select state. Available when <a href=\"#series-scatter.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"progressive":{"type":["number"],"description":"<p><code class=\"codespan\">progressive</code> specifies the amount of graphic elements that can be rendered within a frame (about 16ms) if &quot;progressive rendering&quot; enabled.</p>\n<p>When data amount is from thousand to more than 10 million, it will take too long time to render all of the graphic elements. Since ECharts 4, &quot;progressive rendering&quot; is supported in its workflow, which processes and renders data chunk by chunk alone with each frame, avoiding to block the UI thread of the browser.</p>\n<p>Set <code class=\"codespan\">progressive: 0</code> to disable progressive permanently. By default, progressive is auto-enabled when data amount is bigger than <code class=\"codespan\">progressiveThreshold</code>.</p>\n","default":400},"progressiveThreshold":{"type":["number"],"description":"<p>If current data amount is over the threshold, &quot;progressive rendering&quot; is enabled.</p>\n","default":3000},"dimensions":{"type":["Array"],"description":"<p><code class=\"codespan\">dimensions</code> can be used to define dimension info for <code class=\"codespan\">series.data</code> or <code class=\"codespan\">dataset.source</code>.</p>\n<p>Notice: if <a href=\"#dataset\">dataset</a> is used, we can definite dimensions in <a href=\"#dataset.dimensions\">dataset.dimensions</a>, or provide dimension names in the first column/row of <a href=\"#dataset.source\">dataset.source</a>, and not need to specify <code class=\"codespan\">dimensions</code> here. But if <code class=\"codespan\">dimensions</code> is specified here, it will be used despite the dimension definitions in dataset.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // &#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        // Specify name for each dimesions, which will be displayed in tooltip.\n        dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [\n        null,                // If you do not intent to defined this dimension, use null is fine.\n        {type: &#39;ordinal&#39;},   // Specify type of this dimension.\n                             // &#39;ordinal&#39; is always used in string.\n                             // If type is not specified, echarts will guess type by data.\n        {name: &#39;good&#39;, type: &#39;number&#39;},\n        &#39;bad&#39;                // Equals to {name: &#39;bad&#39;}.\n    ]\n}\n</code></pre>\n<p>Each data item of <code class=\"codespan\">dimensions</code> can be:</p>\n<ul>\n<li><code class=\"codespan\">string</code>, for example, <code class=\"codespan\">&#39;someName&#39;</code>, which equals to <code class=\"codespan\">{name: &#39;someName&#39;}</code>.</li>\n<li><code class=\"codespan\">Object</code>, where the attributes can be:<ul>\n<li>name: <code class=\"codespan\">string</code>.</li>\n<li>type: <code class=\"codespan\">string</code>, supports:<ul>\n<li><code class=\"codespan\">number</code></li>\n<li><code class=\"codespan\">float</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array\" target=\"_blank\">Float64Array</a></li>\n<li><code class=\"codespan\">int</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array\" target=\"_blank\">Int32Array</a></li>\n<li><code class=\"codespan\">ordinal</code>, discrete value, which represents string generally.</li>\n<li><code class=\"codespan\">time</code>, time value, see <a href=\"#series.data\">data</a> to check the format of time value.</li>\n</ul>\n</li>\n<li>displayName: <code class=\"codespan\">string</code>, generally used in tooltip for dimension display. If not specified, use <code class=\"codespan\">name</code> by default.</li>\n</ul>\n</li>\n</ul>\n<p>When <code class=\"codespan\">dimensions</code> is specified, the default <code class=\"codespan\">tooltip</code> will be displayed vertically, which is better to show diemsion names. Otherwise, <code class=\"codespan\">tooltip</code> will displayed only value horizontally.</p>\n"},"encode":{"type":["Object"],"description":"<p>Define what is encoded to for each dimension of <code class=\"codespan\">data</code>. For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // Each column is called a dimension.\n            // There are five dimensions: 0, 1, 2, 3, 4.\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        encode: {\n            x: [3, 1, 5],      // Dimension 3, 1, 5 is mapped to x axis.\n            y: 2,              // Dimension 2 is mapped to y axis.\n            tooltip: [3, 2, 4] // Dimension 3, 2, 4 will be displayed in tooltip.\n        }\n    }\n}\n</code></pre>\n<p>When <a href=\"#series.dimensions\">dimensions</a> is used to defined name for a certain dimension, <code class=\"codespan\">encode</code> can refer the name directly. For example:</p>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;],\n    encode: {\n        x: &#39;date&#39;,\n        y: [&#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<p>The basic structure of <a href=\"option.html#series.encode\" target=\"_blank\">encode</a> is illustrated as follows, where the left part of colon is the name of axis like <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code> or some special reserved names like &quot;tooltip&quot;, &quot;itemName&quot; etc., and the right part of the colon is the dimension names or dimension indices (based on 0). One or more dimensions can be specified. Usually not all of mappings need to be specified, only specify needed ones.</p>\n<p>The properties available in <code class=\"codespan\">encode</code> listed as follows:</p>\n<pre><code class=\"lang-js\">// In any of the series and coordinate systems,\n// these properties are available:\nencode: {\n    // Display dimension &quot;product&quot; and &quot;score&quot; in the tooltip.\n    tooltip: [&#39;product&#39;, &#39;score&#39;]\n    // Set the series name as the concat of the names of dimensions[1] and dimensions[3].\n    // (sometimes the dimension names are too long to type in series.name manually).\n    seriesName: [1, 3],\n    // Using dimensions[2] as the id of each data item. This is useful when dynamically\n    // update data by `chart.setOption()`, where the new and old data item can be\n    // corresponded by id, by which the appropriate animation can be performed when updating.\n    itemId: 2,\n    // Using dimensions[3] as the name of each data item. This is useful in charts like\n    // &#39;pie&#39;, &#39;funnel&#39;, where data item name can be displayed in legend.\n    itemName: 3\n}\n\n// These properties only work in cartesian(grid) coordinate system:\nencode: {\n    // Map dimensions[1], dimensions[5] and dimension &quot;score&quot; to the X axis.\n    x: [1, 5, &#39;score&#39;],\n    // Map dimensions[0] to the Y axis.\n    y: 0\n}\n\n// These properties only work in polar coordinate system:\nencode: {\n    radius: 3,\n    angle: 2,\n    ...\n}\n\n// These properties only work in geo coordinate system:\nencode: {\n    lng: 3,\n    lat: 2\n}\n\n// For some type of series that are not in any coordinate system,\n// like &#39;pie&#39;, &#39;funnel&#39; etc.:\nencode: {\n    value: 3\n}\n</code></pre>\n<p>This is an <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=dataset-encode1&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> for <code class=\"codespan\">encode</code>.</p>\n<p>Specially, in [custom series(~series-custom), some property in <code class=\"codespan\">encode</code>, corresponding to axis, can be set as null to make the series not controlled by the axis, that is, the series data will not be count in the extent of the axis, and the <a href=\"#dataZoom\">dataZoom</a> on the axis will not filter the series.</p>\n<pre><code class=\"lang-js\">var option = {\n    xAxis: {},\n    yAxis: {},\n    dataZoom: [{\n        xAxisIndex: 0\n    }, {\n        yAxisIndex: 0\n    }],\n    series: {\n        type: &#39;custom&#39;,\n        renderItem: function (params, api) {\n            return {\n                type: &#39;circle&#39;,\n                shape: {\n                    cx: 100, // x position is always 100\n                    cy: api.coord([0, api.value(0)])[1],\n                    r: 30\n                },\n                style: {\n                    fill: &#39;blue&#39;\n                }\n            };\n        },\n        encode: {\n            // Then the series will not be controlled\n            // by x axis and corresponding dataZoom.\n            x: -1,\n            y: 1\n        },\n        data: [ ... ]\n    }\n};\n</code></pre>\n"},"seriesLayoutBy":{"type":["string"],"description":"<p>When <a href=\"#dataset\">dataset</a> is used, <code class=\"codespan\">seriesLayoutBy</code> specifies whether the column or the row of <code class=\"codespan\">dataset</code> is mapped to the series, namely, the series is &quot;layout&quot; on columns or rows. Optional values:</p>\n<ul>\n<li>&#39;column&#39;: by default, the columns of <code class=\"codespan\">dataset</code> are mapped the series. In this case, each column represents a dimension.</li>\n<li>&#39;row&#39;：the rows of <code class=\"codespan\">dataset</code> are mapped to the series. In this case, each row represents a dimension.</li>\n</ul>\n<p>Check this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=dataset-series-layout-by\" target=\"_blank\">example</a>.</p>\n","default":"'column'"},"datasetIndex":{"type":["number"],"description":"<p>If <a href=\"#series.data\">series.data</a> is not specified, and <a href=\"#dataset\">dataset</a> exists, the series will use <code class=\"codespan\">dataset</code>. <code class=\"codespan\">datasetIndex</code> specifies which dataset will be used.</p>\n","default":0},"data":{"type":["Array"],"description":"<p>Data array of series, which can be in the following forms:</p>\n<p>Notice, if no <code class=\"codespan\">data</code> specified in series, and there is <a href=\"#dataset\">dataset</a> in option, series will use the first <a href=\"#dataset\">dataset</a> as its datasource. If <code class=\"codespan\">data</code> has been specified, <a href=\"#dataset\">dataset</a> will not used.</p>\n<p><code class=\"codespan\">series.datasetIndex</code> can be used to specify other <a href=\"#dataset\">dataset</a>.</p>\n<p>Basically, data is represented by a two-dimension array, like the example below, where each column is named as a &quot;dimension&quot;.</p>\n<pre><code class=\"lang-js\">series: [{\n    data: [\n        // dimX   dimY   other dimensions ...\n        [  3.4,    4.5,   15,   43],\n        [  4.2,    2.3,   20,   91],\n        [  10.8,   9.5,   30,   18],\n        [  7.2,    8.8,   18,   57]\n    ]\n}]\n</code></pre>\n<ul>\n<li>In <a href=\"#grid\">cartesian (grid)</a>, &quot;dimX&quot; and &quot;dimY&quot; correspond to <a href=\"#xAxis\">xAxis</a> and <a href=\"#yAxis\">yAxis</a> respectively.</li>\n<li>In <a href=\"#polar\">polar</a> &quot;dimX&quot; and &quot;dimY&quot; correspond to <a href=\"#radiusAxis\">radiusAxis</a> 和 <a href=\"#anbleAxis\">angleAxis</a> respectively.</li>\n<li>Other dimensions are optional, which can be used in other places. For example:<ul>\n<li><a href=\"#visualMap\">visualMap</a> can map one or more dimensions to visual (color, symbol size ...).</li>\n<li><a href=\"#series.symbolSize\">series.symbolSize</a> can be set as a callback function, where symbol size can be calculated by values of a certain dimension.</li>\n<li>Values in other dimensions can be shown by <a href=\"#tooltip.formatter\">tooltip.formatter</a> or <a href=\"#series.label.formatter\">series.label.formatter</a>.</li>\n</ul>\n</li>\n</ul>\n<p>Especially, when there is one and only one category axis (axis.type is <code class=\"codespan\">&#39;category&#39;</code>), data can be simply be represented by a one-dimension array, like:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    data: [&#39;a&#39;, &#39;b&#39;, &#39;m&#39;, &#39;n&#39;]\n},\nseries: [{\n    // Each item corresponds to each item in xAxis.data.\n    data: [23,  44,  55,  19]\n    // In fact, it is the simplification of the format below:\n    // data: [[0, 23], [1, 44], [2, 55], [3, 19]]\n}]\n</code></pre>\n<p><br>\n<strong>Relationship between &quot;value&quot; and <a href=\"#xAxis.type\">axis.type</a></strong></p>\n<ul>\n<li><p>When a dimension corresponds to a value axis (axis.type is <code class=\"codespan\">&#39;value&#39;</code> or <code class=\"codespan\">&#39;log&#39;</code>):</p>\n<p>  The value can be a <code class=\"codespan\">number</code> (like <code class=\"codespan\">12</code>) (can also be a number in a <code class=\"codespan\">string</code> format, like <code class=\"codespan\">&#39;12&#39;</code>).</p>\n</li>\n<li><p>When a dimension corresponds to a category axis (axis.type is <code class=\"codespan\">&#39;category&#39;</code>):</p>\n<p>  The value should be the ordinal of the axis.data (based on <code class=\"codespan\">0</code>), the string value of the axis.data. For example:</p>\n<pre><code class=\"lang-js\">  xAxis: {\n      type: &#39;category&#39;,\n      data: [&#39;Monday&#39;, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;]\n  },\n  yAxis: {\n      type: &#39;category&#39;,\n      data: [&#39;a&#39;, &#39;b&#39;, &#39;m&#39;, &#39;n&#39;, &#39;p&#39;, &#39;q&#39;]\n  },\n  series: [{\n      data: [\n          // xAxis      yAxis\n          [  0,           0,    2  ], // This point is located at xAxis: &#39;Monday&#39;, yAxis: &#39;a&#39;.\n          [  &#39;Thursday&#39;,  2,    1  ], // This point is located at xAxis: &#39;Thursday&#39;, yAxis: &#39;m&#39;.\n          [  2,          &#39;p&#39;,   2  ], // This point is located at xAxis: &#39;Wednesday&#39;, yAxis: &#39;p&#39;.\n          [  3,           3,    5  ]\n      ]\n  }]\n</code></pre>\n<p>  There is an example of double category axes: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-punchCard\" target=\"_blank\">Github Punchcard</a>.</p>\n</li>\n<li><p>When a dimension corresponds to a time axis (type is <code class=\"codespan\">&#39;time&#39;</code>), the value can be:</p>\n<ul>\n<li>a timestamp, like <code class=\"codespan\">1484141700832</code>, which represents a UTC time.</li>\n<li>a date string, in one of the formats below:<ul>\n<li>a subset of <a href=\"http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15\" target=\"_blank\">ISO 8601</a>, only including (all of these are treated as local time unless timezone is specified, which is consistent with <a href=\"https://momentjs.com/\" target=\"_blank\">moment</a>):<ul>\n<li>only part of year/month/date/time are specified: <code class=\"codespan\">&#39;2012-03&#39;</code>, <code class=\"codespan\">&#39;2012-03-01&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 05&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 05:06&#39;</code>.</li>\n<li>separated by <code class=\"codespan\">&quot;T&quot;</code> or a space: <code class=\"codespan\">&#39;2012-03-01T12:22:33.123&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 12:22:33.123&#39;</code>.</li>\n<li>timezone specified: <code class=\"codespan\">&#39;2012-03-01T12:22:33Z&#39;</code>, <code class=\"codespan\">&#39;2012-03-01T12:22:33+8000&#39;</code>, <code class=\"codespan\">&#39;2012-03-01T12:22:33-05:00&#39;</code>.</li>\n</ul>\n</li>\n<li>other date string format (all of these are treated as local time):\n<code class=\"codespan\">&#39;2012&#39;</code>, <code class=\"codespan\">&#39;2012-3-1&#39;</code>, <code class=\"codespan\">&#39;2012/3/1&#39;</code>, <code class=\"codespan\">&#39;2012/03/01&#39;</code>,\n<code class=\"codespan\">&#39;2009/6/12 2:00&#39;</code>, <code class=\"codespan\">&#39;2009/6/12 2:05:08&#39;</code>, <code class=\"codespan\">&#39;2009/6/12 2:05:08.123&#39;</code>.</li>\n</ul>\n</li>\n<li>a JavaScript Date instance created by user:<ul>\n<li>Caution, when using a data string to create a Date instance, <a href=\"http://dygraphs.com/date-formats.html\" target=\"_blank\">browser differences and inconsistencies</a> should be considered.</li>\n<li>For example: In chrome, <code class=\"codespan\">new Date(&#39;2012-01-01&#39;)</code> is treated as a Jan 1st 2012 in UTC, while <code class=\"codespan\">new Date(&#39;2012-1-1&#39;)</code> and <code class=\"codespan\">new Date(&#39;2012/01/01&#39;)</code> are treated as Jan 1st 2012 in local timezone. In safari <code class=\"codespan\">new Date(&#39;2012-1-1&#39;)</code> is not supported.</li>\n<li>So if you intent to perform <code class=\"codespan\">new Date(dateString)</code>, it is strongly recommended to use a time parse library (e.g., <a href=\"https://momentjs.com/\" target=\"_blank\">moment</a>), or use <code class=\"codespan\">echarts.number.parseDate</code>, or check <a href=\"http://dygraphs.com/date-formats.html\" target=\"_blank\">this</a>.</li>\n</ul>\n</li>\n</ul>\n</li>\n</ul>\n<p><br>\n<strong>Customize a data item:</strong></p>\n<p>When needing to customize a data item, it can be set as an object, where property <code class=\"codespan\">value</code> reprensent real value. For example:</p>\n<pre><code class=\"lang-js\">[\n    12,\n    24,\n    {\n        value: [24, 32],\n        // label style, only works in this data item.\n        label: {},\n        // item style, only works in this data item.\n        itemStyle:{}\n    },\n    33\n]\n// Or\n[\n    [12, 332],\n    [24, 32],\n    {\n        value: [24, 32],\n        // label style, only works in this data item.\n        label: {},\n        // item style, only works in this data item.\n        itemStyle:{}\n    },\n    [33, 31]\n]\n</code></pre>\n<p><br>\n<strong>Empty value:</strong></p>\n<p><code class=\"codespan\">&#39;-&#39;</code> or <code class=\"codespan\">null</code> or <code class=\"codespan\">undefined</code> or <code class=\"codespan\">NaN</code> can be used to describe that a data item does not exist (ps：<em>not exist</em> does not means its value is <code class=\"codespan\">0</code>).</p>\n<p>For example, line chart can break when encounter an empty value, and scatter chart do not display graphic elements for empty values.</p>\n<p><br><br></p>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>the name of data item.</p>\n"},"value":{"type":["Array"],"description":"<p>the value of data item.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of single data.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>single data symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of single data symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of single data symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"inside"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>the style setting about single data point(bubble).</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of single data.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state of single data.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state of single data.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series data.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}}},"markPoint":{"type":["Object"],"description":"<p>Mark point in a chart.</p>\n","properties":{"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-scatter.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'pin'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-scatter.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":50},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-scatter.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label of mark point.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark point.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Data array for mark points, each of which is an object. Here are some ways to assign mark point position.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-scatter.markPoint.data.x\">x</a>, <a href=\"#series-scatter.markPoint.data.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li><p>Assign coordinate position with <a href=\"#series-scatter.markPoint.data.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</p>\n</li>\n<li><p>Use <a href=\"#series-scatter.markPoint.data.type\">type</a> attribute to mark the maximum and minimum values in the series, in which <a href=\"#series-scatter.markPoint.data.valueIndex\">valueIndex</a> or <a href=\"#series-scatter.markPoint.data.valueDim\">valueDim</a> can be used to assign the dimension.</p>\n</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p><strong>For example: </strong></p>\n<pre><code class=\"lang-js\">data: [\n    {\n        name: &#39;maximum&#39;,\n        type: &#39;max&#39;\n    }, \n    {\n        name: &#39;coordinate&#39;,\n        coord: [10, 20]\n    }, {\n        name: &#39;fixed x position&#39;,\n        yAxis: 10,\n        x: &#39;90%&#39;\n    }, \n\n    {\n        name: &#39;screen coordinate&#39;,\n        x: 100,\n        y: 100\n    }\n]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Mark point name.</p>\n","default":"''"},"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Available when using <a href=\"#series-scatter.markPoint.data.type\">type</a> it is used to assign maximum value and minimum value in dimensions, it could be <code class=\"codespan\">0</code> (xAxis, radiusAxis), <code class=\"codespan\">1</code> (yAxis, angleAxis), and use the first value axis dimension by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-scatter.markPoint.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markLine":{"type":["Object"],"description":"<p>Use a line in the chart to illustrate.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"symbol":{"type":["string","Array"],"description":"<p>Symbol type at the two ends of the mark line. It can be an array for two ends, or assigned seperately. See <a href=\"#series-scatter.markLine.data.0.symbol\">data.symbol</a> for more format information.</p>\n"},"symbolSize":{"type":["number","Array"],"description":"<p>Symbol size at the two ends of the mark line. It can be an array for two ends, or assigned seperately.</p>\n<p><strong>Attention: </strong> You cannot assgin width and height seperately as normal <code class=\"codespan\">symbolSize</code>.</p>\n"},"precision":{"type":["number"],"description":"<p>Precision of marking line value, which is useful when displaying average value mark line.</p>\n","default":2},"label":{"type":["Object"],"description":"<p>Mark line text.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"<p>Mark line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark line.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>Data array of marking line. Every array item can be an array of one or two values, representing starting and ending point of the line, and every item is an object. Here are several ways to assign the positions of starting and ending point.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-scatter.markLine.data.0.x\">x</a>, <a href=\"#series-scatter.markLine.data.0.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li><p>Assign coordinate position with <a href=\"#series-scatter.markLine.data.0.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</p>\n</li>\n<li><p>Use <a href=\"#series-scatter.markLine.data.0.type\">type</a> attribute to mark the maximum and minimum values in the series, in which <a href=\"#series-scatter.markLine.data.0.valueIndex\">valueIndex</a> or <a href=\"#series-scatter.markLine.data.0.valueDim\">valueDim</a> can be used to assign the dimension.</p>\n</li>\n<li><p>You may also create a mark line in Cartesian coordinate at a specific position in X or Y axis by assigning <code class=\"codespan\">xAxis</code> or <code class=\"codespan\">yAxis</code>. See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-weight\" target=\"_blank\">scatter-weight</a> for example.</p>\n</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p>You may also set the type of mark line through <code class=\"codespan\">type</code>, stating whether it is for the maximum value or average value. Likewise, dimensions can be assigned through <code class=\"codespan\">valueIndex</code>.</p>\n<pre><code>data: [\n\n{\n        name: &#39;average line&#39;,\n        // &#39;average&#39;, &#39;min&#39;, and &#39;max&#39; are supported\n        type: &#39;average&#39;\n    },\n    {\n        name: &#39;Horizontal line with Y value at 100&#39;,\n        yAxis: 100\n    },\n    [\n        {\n            // Use the same name with starting and ending point\n            name: &#39;Minimum to Maximum&#39;,\n            type: &#39;min&#39;\n        },\n        {\n            type: &#39;max&#39;\n        }\n    ],\n[\n        {\n            name: &#39;Markline between two points&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [{\n        // Mark line with a fixed X position in starting point. This is used to generate an arrow pointing to maximum line.\n        yAxis: &#39;max&#39;,\n        x: &#39;90%&#39;\n    }, {\n        type: &#39;max&#39;\n    }],\n[\n        {\n            name: &#39;Mark line between two points&#39;,\n            x: 100,\n            y: 100\n        },\n        {\n            x: 500,\n            y: 200\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Data of the starting point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n<li><code class=\"codespan\">&#39;median&#39;</code> median value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-scatter.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-scatter.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'starting point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of starting point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>starting point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of starting point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of starting point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Data of the ending point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n<li><code class=\"codespan\">&#39;median&#39;</code> median value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-scatter.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-scatter.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'ending point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of ending point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>ending point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of ending point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of ending point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markArea":{"type":["Object"],"description":"<p>Used to mark an area in chart. For example, mark a time interval.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label in mark area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Style of the mark area.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark area.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>The scope of the area is defined by <code class=\"codespan\">data</code>, which is an array with two item, representing the left-top point and the right-bottom point of rectangle area. Each item can be defined as follows:</p>\n<ol>\n<li>Specify the coordinate in screen coordinate system using <a href=\"#series-scatter.markArea.data.0.x\">x</a>, <a href=\"#series-scatter.markArea.data.0.y\">y</a>, where the unit is pixel (e.g., the value is <code class=\"codespan\">5</code>), or percent (e.g., the value is <code class=\"codespan\">&#39;35%&#39;</code>).</li>\n</ol>\n<ol start=\"2\">\n<li><p>Specify the coordinate in data coordinate system (i.e., cartesian) using\n<a href=\"#series-scatter.markArea.data.0.coord\">coord</a>, which can be also set as <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> (e.g, <code class=\"codespan\">coord: [23, &#39;min&#39;]</code>, or <code class=\"codespan\">coord: [&#39;average&#39;, &#39;max&#39;]</code>).</p>\n</li>\n<li><p>Locate the point on the min value or max value of <code class=\"codespan\">series.data</code> using <a href=\"#series-scatter.markArea.data.0.type\">type</a>, where <a href=\"#series-scatter.markArea.data.0.valueIndex\">valueIndex</a> or <a href=\"#series-scatter.markPoint.data.0.valueDim\">valueDim</a> can be used to specify the dimension on which the min, max or average are calculated.</p>\n</li>\n<li>If in cartesian, you can only specify <code class=\"codespan\">xAxis</code> or <code class=\"codespan\">yAxis</code> to define a mark area based on only X or Y axis, see sample <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-weight\" target=\"_blank\">scatter-weight</a></li>\n</ol>\n<p>The priority follows as above if more than one above definition used.</p>\n<pre><code>data: [\n\n\n    [\n        {\n            name: &#39;From average to max&#39;,\n            type: &#39;average&#39;\n        },\n        {\n            type: &#39;max&#39;\n        }\n    ],\n\n    [\n        {\n            name: &#39;Mark area between two points in data coordiantes&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [\n        {\n            name: &#39;From 60 to 80&#39;,\n            yAxis: 60\n        },\n        {\n            yAxis: 80\n        }\n    ], [\n        {\n            name: &#39;Mark area covers all data&#39;\n            coord: [&#39;min&#39;, &#39;min&#39;]\n        },\n        {\n            coord: [&#39;max&#39;, &#39;max&#39;]\n        }\n    ],\n[\n        {\n            name: &#39;Mark area in two screen points&#39;,\n            x: 100,\n            y: 100\n        }, {\n            x: &#39;90%&#39;,\n            y: &#39;10%&#39;\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Specify the left-top point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Specify this item is on min or max or average value.</p>\n<p><strong>Options:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> max value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> min value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-scatter.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-scatter.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'start'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Specify the right-bottom point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Specify this item is on min or max or average value.</p>\n<p><strong>Options:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> max value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> min value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-scatter.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-scatter.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'end'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"false","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"clip":{"type":["boolean"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v4.4.0</code></p>\n</blockquote>\n<p>If clip the overflow on the coordinate system. Clip results varies between series:</p>\n<ul>\n<li>Scatter：Ignore the symbols exceeds the coordinate system. Not clip the elements.</li>\n<li>Bar：Clip all the overflowed. With bar width kept.</li>\n<li>Line：Clip the overflowed line.</li>\n<li>Lines: Clip all the overflowed.</li>\n<li>Candlestick: Ignore the elements exceeds the coordinate system.</li>\n<li>Custom: Clip all the olverflowed.</li>\n</ul>\n<p>All these series have default value <code class=\"codespan\">true</code> except custom series. Set it to <code class=\"codespan\">false</code> if you don&#39;t want to clip.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in Scatter.</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in Scatter, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p>The scatter (bubble) graph with ripple animation. The special animation effect can visually highlights some data.</p>\n<p><strong>Tip:</strong>  The effects of map was achieved through markPoint in ECharts 2.x. However, in  ECharts 3, effectScatter on geographic coordinate is recommended for achieving that effects of map.</p>\n","properties":{"type":{"type":["string"],"description":"","default":"'effectScatter'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"legendHoverLink":{"type":["boolean"],"description":"\n\n<p>Whether to enable highlighting chart when <a href=\"#legend\">legend</a> is being hovered.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"effectType":{"type":["string"],"description":"\n\n<p>Type of effect. Only ripple effect of <code class=\"codespan\">&#39;ripple&#39;</code> is supported currently.</p>\n","uiControl":{"type":"enum","options":"ripple"},"default":"'ripple'"},"showEffectOn":{"type":["string"],"description":"\n\n<p>When to show the effect.</p>\n<p><strong>Options: </strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;render&#39;</code> Show the effect when rendering is done.</li>\n<li><code class=\"codespan\">&#39;emphasis&#39;</code> Show the effect when it is highlight (hover).</li>\n</ul>\n","uiControl":{"type":"enum","options":"render,emphasis","default":"render"},"default":"'render'"},"rippleEffect":{"type":["Object"],"description":"<p>Related configurations about ripple effect.</p>\n","properties":{"color":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.4.0</code></p>\n</blockquote>\n\n\n<p>Color of the ripple rings. The default value is the color of scatter.</p>\n","uiControl":{"type":"color"}},"period":{"type":["number"],"description":"\n\n<p>The period duration of animation, in seconds.</p>\n","uiControl":{"type":"number","min":"0","default":"4","step":"0.1"},"default":4},"scale":{"type":["number"],"description":"\n\n<p>The maximum zooming scale of ripples in animation.</p>\n","uiControl":{"type":"number","min":"1","default":"2.5","step":"0.1"},"default":2.5},"brushType":{"type":["string"],"description":"\n\n<p>The brush type for ripples. options: <code class=\"codespan\">&#39;stroke&#39;</code> and <code class=\"codespan\">&#39;fill&#39;</code>.</p>\n","uiControl":{"type":"enum","options":"stroke,fill","default":"fill"},"default":"'fill'"}}},"coordinateSystem":{"type":["string"],"description":"<p>The coordinate used in the series, whose options are:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;cartesian2d&#39;</code></p>\n<p>  Use a two-dimensional rectangular coordinate (also known as Cartesian coordinate), with <a href=\"#series-bar.xAxisIndex\">xAxisIndex</a> and <a href=\"#series-bar.yAxisIndex\">yAxisIndex</a> to assign the corresponding axis component.</p>\n</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;polar&#39;</code></p>\n<p>  Use polar coordinates, with <a href=\"#series-bar.polarIndex\">polarIndex</a> to assign the corresponding polar coordinate component.</p>\n</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;geo&#39;</code></p>\n<p>  Use geographic coordinate, with <a href=\"#series-bar.geoIndex\">geoIndex</a> to assign the corresponding geographic coordinate components.</p>\n</li>\n</ul>\n","default":"'cartesian2d'"},"xAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#xAxis\">x axis</a> to combine with, which is  useful for multiple x axes in one chart.</p>\n","default":0},"yAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#yAxis\">y axis</a> to combine with, which is  useful for multiple y axes in one chart.</p>\n","default":0},"polarIndex":{"type":["number"],"description":"<p>Index of <a href=\"#polar\">polar coordinate</a> to combine with, which is useful for multiple polar axes in one chart.</p>\n","default":0},"geoIndex":{"type":["number"],"description":"<p>Index of <a href=\"#geo\">geographic coordinate</a> to combine with, which is useful for multiple geographic axes in one chart.</p>\n","default":0},"calendarIndex":{"type":["number"],"description":"<p>Index of <a href=\"#calendar\">calendar coordinates</a> to combine with, which is useful for multiple calendar coordinates in one chart.</p>\n","default":0},"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-effectScatter.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'circle'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-effectScatter.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":10},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-effectScatter.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"label":{"type":["Object"],"description":"<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of , <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"color":{"type":["Color","Function"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n<p>Supports callback functions, in the form of:</p>\n<pre><code class=\"lang-js\">(params: Object) =&gt; Color\n</code></pre>\n<p>Input parameters are <code class=\"codespan\">seriesIndex</code>, <code class=\"codespan\">dataIndex</code>, <code class=\"codespan\">data</code>, <code class=\"codespan\">value</code>, and etc. of data item.</p>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"scale":{"type":["boolean"],"description":"\n\n<p>Whether to scale to highlight the data in emphasis state.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Available when <a href=\"#series-effectScatter.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of select state. Available when <a href=\"#series-effectScatter.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"seriesLayoutBy":{"type":["string"],"description":"<p>When <a href=\"#dataset\">dataset</a> is used, <code class=\"codespan\">seriesLayoutBy</code> specifies whether the column or the row of <code class=\"codespan\">dataset</code> is mapped to the series, namely, the series is &quot;layout&quot; on columns or rows. Optional values:</p>\n<ul>\n<li>&#39;column&#39;: by default, the columns of <code class=\"codespan\">dataset</code> are mapped the series. In this case, each column represents a dimension.</li>\n<li>&#39;row&#39;：the rows of <code class=\"codespan\">dataset</code> are mapped to the series. In this case, each row represents a dimension.</li>\n</ul>\n<p>Check this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=dataset-series-layout-by\" target=\"_blank\">example</a>.</p>\n","default":"'column'"},"datasetIndex":{"type":["number"],"description":"<p>If <a href=\"#series.data\">series.data</a> is not specified, and <a href=\"#dataset\">dataset</a> exists, the series will use <code class=\"codespan\">dataset</code>. <code class=\"codespan\">datasetIndex</code> specifies which dataset will be used.</p>\n","default":0},"dimensions":{"type":["Array"],"description":"<p><code class=\"codespan\">dimensions</code> can be used to define dimension info for <code class=\"codespan\">series.data</code> or <code class=\"codespan\">dataset.source</code>.</p>\n<p>Notice: if <a href=\"#dataset\">dataset</a> is used, we can definite dimensions in <a href=\"#dataset.dimensions\">dataset.dimensions</a>, or provide dimension names in the first column/row of <a href=\"#dataset.source\">dataset.source</a>, and not need to specify <code class=\"codespan\">dimensions</code> here. But if <code class=\"codespan\">dimensions</code> is specified here, it will be used despite the dimension definitions in dataset.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // &#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        // Specify name for each dimesions, which will be displayed in tooltip.\n        dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [\n        null,                // If you do not intent to defined this dimension, use null is fine.\n        {type: &#39;ordinal&#39;},   // Specify type of this dimension.\n                             // &#39;ordinal&#39; is always used in string.\n                             // If type is not specified, echarts will guess type by data.\n        {name: &#39;good&#39;, type: &#39;number&#39;},\n        &#39;bad&#39;                // Equals to {name: &#39;bad&#39;}.\n    ]\n}\n</code></pre>\n<p>Each data item of <code class=\"codespan\">dimensions</code> can be:</p>\n<ul>\n<li><code class=\"codespan\">string</code>, for example, <code class=\"codespan\">&#39;someName&#39;</code>, which equals to <code class=\"codespan\">{name: &#39;someName&#39;}</code>.</li>\n<li><code class=\"codespan\">Object</code>, where the attributes can be:<ul>\n<li>name: <code class=\"codespan\">string</code>.</li>\n<li>type: <code class=\"codespan\">string</code>, supports:<ul>\n<li><code class=\"codespan\">number</code></li>\n<li><code class=\"codespan\">float</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array\" target=\"_blank\">Float64Array</a></li>\n<li><code class=\"codespan\">int</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array\" target=\"_blank\">Int32Array</a></li>\n<li><code class=\"codespan\">ordinal</code>, discrete value, which represents string generally.</li>\n<li><code class=\"codespan\">time</code>, time value, see <a href=\"#series.data\">data</a> to check the format of time value.</li>\n</ul>\n</li>\n<li>displayName: <code class=\"codespan\">string</code>, generally used in tooltip for dimension display. If not specified, use <code class=\"codespan\">name</code> by default.</li>\n</ul>\n</li>\n</ul>\n<p>When <code class=\"codespan\">dimensions</code> is specified, the default <code class=\"codespan\">tooltip</code> will be displayed vertically, which is better to show diemsion names. Otherwise, <code class=\"codespan\">tooltip</code> will displayed only value horizontally.</p>\n"},"encode":{"type":["Object"],"description":"<p>Define what is encoded to for each dimension of <code class=\"codespan\">data</code>. For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // Each column is called a dimension.\n            // There are five dimensions: 0, 1, 2, 3, 4.\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        encode: {\n            x: [3, 1, 5],      // Dimension 3, 1, 5 is mapped to x axis.\n            y: 2,              // Dimension 2 is mapped to y axis.\n            tooltip: [3, 2, 4] // Dimension 3, 2, 4 will be displayed in tooltip.\n        }\n    }\n}\n</code></pre>\n<p>When <a href=\"#series.dimensions\">dimensions</a> is used to defined name for a certain dimension, <code class=\"codespan\">encode</code> can refer the name directly. For example:</p>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;],\n    encode: {\n        x: &#39;date&#39;,\n        y: [&#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<p>The basic structure of <a href=\"option.html#series.encode\" target=\"_blank\">encode</a> is illustrated as follows, where the left part of colon is the name of axis like <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code> or some special reserved names like &quot;tooltip&quot;, &quot;itemName&quot; etc., and the right part of the colon is the dimension names or dimension indices (based on 0). One or more dimensions can be specified. Usually not all of mappings need to be specified, only specify needed ones.</p>\n<p>The properties available in <code class=\"codespan\">encode</code> listed as follows:</p>\n<pre><code class=\"lang-js\">// In any of the series and coordinate systems,\n// these properties are available:\nencode: {\n    // Display dimension &quot;product&quot; and &quot;score&quot; in the tooltip.\n    tooltip: [&#39;product&#39;, &#39;score&#39;]\n    // Set the series name as the concat of the names of dimensions[1] and dimensions[3].\n    // (sometimes the dimension names are too long to type in series.name manually).\n    seriesName: [1, 3],\n    // Using dimensions[2] as the id of each data item. This is useful when dynamically\n    // update data by `chart.setOption()`, where the new and old data item can be\n    // corresponded by id, by which the appropriate animation can be performed when updating.\n    itemId: 2,\n    // Using dimensions[3] as the name of each data item. This is useful in charts like\n    // &#39;pie&#39;, &#39;funnel&#39;, where data item name can be displayed in legend.\n    itemName: 3\n}\n\n// These properties only work in cartesian(grid) coordinate system:\nencode: {\n    // Map dimensions[1], dimensions[5] and dimension &quot;score&quot; to the X axis.\n    x: [1, 5, &#39;score&#39;],\n    // Map dimensions[0] to the Y axis.\n    y: 0\n}\n\n// These properties only work in polar coordinate system:\nencode: {\n    radius: 3,\n    angle: 2,\n    ...\n}\n\n// These properties only work in geo coordinate system:\nencode: {\n    lng: 3,\n    lat: 2\n}\n\n// For some type of series that are not in any coordinate system,\n// like &#39;pie&#39;, &#39;funnel&#39; etc.:\nencode: {\n    value: 3\n}\n</code></pre>\n<p>This is an <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=dataset-encode1&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> for <code class=\"codespan\">encode</code>.</p>\n<p>Specially, in [custom series(~series-custom), some property in <code class=\"codespan\">encode</code>, corresponding to axis, can be set as null to make the series not controlled by the axis, that is, the series data will not be count in the extent of the axis, and the <a href=\"#dataZoom\">dataZoom</a> on the axis will not filter the series.</p>\n<pre><code class=\"lang-js\">var option = {\n    xAxis: {},\n    yAxis: {},\n    dataZoom: [{\n        xAxisIndex: 0\n    }, {\n        yAxisIndex: 0\n    }],\n    series: {\n        type: &#39;custom&#39;,\n        renderItem: function (params, api) {\n            return {\n                type: &#39;circle&#39;,\n                shape: {\n                    cx: 100, // x position is always 100\n                    cy: api.coord([0, api.value(0)])[1],\n                    r: 30\n                },\n                style: {\n                    fill: &#39;blue&#39;\n                }\n            };\n        },\n        encode: {\n            // Then the series will not be controlled\n            // by x axis and corresponding dataZoom.\n            x: -1,\n            y: 1\n        },\n        data: [ ... ]\n    }\n};\n</code></pre>\n"},"data":{"type":["Array"],"description":"<p>Data array of series, which can be in the following forms:</p>\n<p>Notice, if no <code class=\"codespan\">data</code> specified in series, and there is <a href=\"#dataset\">dataset</a> in option, series will use the first <a href=\"#dataset\">dataset</a> as its datasource. If <code class=\"codespan\">data</code> has been specified, <a href=\"#dataset\">dataset</a> will not used.</p>\n<p><code class=\"codespan\">series.datasetIndex</code> can be used to specify other <a href=\"#dataset\">dataset</a>.</p>\n<p>Basically, data is represented by a two-dimension array, like the example below, where each column is named as a &quot;dimension&quot;.</p>\n<pre><code class=\"lang-js\">series: [{\n    data: [\n        // dimX   dimY   other dimensions ...\n        [  3.4,    4.5,   15,   43],\n        [  4.2,    2.3,   20,   91],\n        [  10.8,   9.5,   30,   18],\n        [  7.2,    8.8,   18,   57]\n    ]\n}]\n</code></pre>\n<ul>\n<li>In <a href=\"#grid\">cartesian (grid)</a>, &quot;dimX&quot; and &quot;dimY&quot; correspond to <a href=\"#xAxis\">xAxis</a> and <a href=\"#yAxis\">yAxis</a> respectively.</li>\n<li>In <a href=\"#polar\">polar</a> &quot;dimX&quot; and &quot;dimY&quot; correspond to <a href=\"#radiusAxis\">radiusAxis</a> 和 <a href=\"#anbleAxis\">angleAxis</a> respectively.</li>\n<li>Other dimensions are optional, which can be used in other places. For example:<ul>\n<li><a href=\"#visualMap\">visualMap</a> can map one or more dimensions to visual (color, symbol size ...).</li>\n<li><a href=\"#series.symbolSize\">series.symbolSize</a> can be set as a callback function, where symbol size can be calculated by values of a certain dimension.</li>\n<li>Values in other dimensions can be shown by <a href=\"#tooltip.formatter\">tooltip.formatter</a> or <a href=\"#series.label.formatter\">series.label.formatter</a>.</li>\n</ul>\n</li>\n</ul>\n<p>Especially, when there is one and only one category axis (axis.type is <code class=\"codespan\">&#39;category&#39;</code>), data can be simply be represented by a one-dimension array, like:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    data: [&#39;a&#39;, &#39;b&#39;, &#39;m&#39;, &#39;n&#39;]\n},\nseries: [{\n    // Each item corresponds to each item in xAxis.data.\n    data: [23,  44,  55,  19]\n    // In fact, it is the simplification of the format below:\n    // data: [[0, 23], [1, 44], [2, 55], [3, 19]]\n}]\n</code></pre>\n<p><br>\n<strong>Relationship between &quot;value&quot; and <a href=\"#xAxis.type\">axis.type</a></strong></p>\n<ul>\n<li><p>When a dimension corresponds to a value axis (axis.type is <code class=\"codespan\">&#39;value&#39;</code> or <code class=\"codespan\">&#39;log&#39;</code>):</p>\n<p>  The value can be a <code class=\"codespan\">number</code> (like <code class=\"codespan\">12</code>) (can also be a number in a <code class=\"codespan\">string</code> format, like <code class=\"codespan\">&#39;12&#39;</code>).</p>\n</li>\n<li><p>When a dimension corresponds to a category axis (axis.type is <code class=\"codespan\">&#39;category&#39;</code>):</p>\n<p>  The value should be the ordinal of the axis.data (based on <code class=\"codespan\">0</code>), the string value of the axis.data. For example:</p>\n<pre><code class=\"lang-js\">  xAxis: {\n      type: &#39;category&#39;,\n      data: [&#39;Monday&#39;, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;]\n  },\n  yAxis: {\n      type: &#39;category&#39;,\n      data: [&#39;a&#39;, &#39;b&#39;, &#39;m&#39;, &#39;n&#39;, &#39;p&#39;, &#39;q&#39;]\n  },\n  series: [{\n      data: [\n          // xAxis      yAxis\n          [  0,           0,    2  ], // This point is located at xAxis: &#39;Monday&#39;, yAxis: &#39;a&#39;.\n          [  &#39;Thursday&#39;,  2,    1  ], // This point is located at xAxis: &#39;Thursday&#39;, yAxis: &#39;m&#39;.\n          [  2,          &#39;p&#39;,   2  ], // This point is located at xAxis: &#39;Wednesday&#39;, yAxis: &#39;p&#39;.\n          [  3,           3,    5  ]\n      ]\n  }]\n</code></pre>\n<p>  There is an example of double category axes: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-punchCard\" target=\"_blank\">Github Punchcard</a>.</p>\n</li>\n<li><p>When a dimension corresponds to a time axis (type is <code class=\"codespan\">&#39;time&#39;</code>), the value can be:</p>\n<ul>\n<li>a timestamp, like <code class=\"codespan\">1484141700832</code>, which represents a UTC time.</li>\n<li>a date string, in one of the formats below:<ul>\n<li>a subset of <a href=\"http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15\" target=\"_blank\">ISO 8601</a>, only including (all of these are treated as local time unless timezone is specified, which is consistent with <a href=\"https://momentjs.com/\" target=\"_blank\">moment</a>):<ul>\n<li>only part of year/month/date/time are specified: <code class=\"codespan\">&#39;2012-03&#39;</code>, <code class=\"codespan\">&#39;2012-03-01&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 05&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 05:06&#39;</code>.</li>\n<li>separated by <code class=\"codespan\">&quot;T&quot;</code> or a space: <code class=\"codespan\">&#39;2012-03-01T12:22:33.123&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 12:22:33.123&#39;</code>.</li>\n<li>timezone specified: <code class=\"codespan\">&#39;2012-03-01T12:22:33Z&#39;</code>, <code class=\"codespan\">&#39;2012-03-01T12:22:33+8000&#39;</code>, <code class=\"codespan\">&#39;2012-03-01T12:22:33-05:00&#39;</code>.</li>\n</ul>\n</li>\n<li>other date string format (all of these are treated as local time):\n<code class=\"codespan\">&#39;2012&#39;</code>, <code class=\"codespan\">&#39;2012-3-1&#39;</code>, <code class=\"codespan\">&#39;2012/3/1&#39;</code>, <code class=\"codespan\">&#39;2012/03/01&#39;</code>,\n<code class=\"codespan\">&#39;2009/6/12 2:00&#39;</code>, <code class=\"codespan\">&#39;2009/6/12 2:05:08&#39;</code>, <code class=\"codespan\">&#39;2009/6/12 2:05:08.123&#39;</code>.</li>\n</ul>\n</li>\n<li>a JavaScript Date instance created by user:<ul>\n<li>Caution, when using a data string to create a Date instance, <a href=\"http://dygraphs.com/date-formats.html\" target=\"_blank\">browser differences and inconsistencies</a> should be considered.</li>\n<li>For example: In chrome, <code class=\"codespan\">new Date(&#39;2012-01-01&#39;)</code> is treated as a Jan 1st 2012 in UTC, while <code class=\"codespan\">new Date(&#39;2012-1-1&#39;)</code> and <code class=\"codespan\">new Date(&#39;2012/01/01&#39;)</code> are treated as Jan 1st 2012 in local timezone. In safari <code class=\"codespan\">new Date(&#39;2012-1-1&#39;)</code> is not supported.</li>\n<li>So if you intent to perform <code class=\"codespan\">new Date(dateString)</code>, it is strongly recommended to use a time parse library (e.g., <a href=\"https://momentjs.com/\" target=\"_blank\">moment</a>), or use <code class=\"codespan\">echarts.number.parseDate</code>, or check <a href=\"http://dygraphs.com/date-formats.html\" target=\"_blank\">this</a>.</li>\n</ul>\n</li>\n</ul>\n</li>\n</ul>\n<p><br>\n<strong>Customize a data item:</strong></p>\n<p>When needing to customize a data item, it can be set as an object, where property <code class=\"codespan\">value</code> reprensent real value. For example:</p>\n<pre><code class=\"lang-js\">[\n    12,\n    24,\n    {\n        value: [24, 32],\n        // label style, only works in this data item.\n        label: {},\n        // item style, only works in this data item.\n        itemStyle:{}\n    },\n    33\n]\n// Or\n[\n    [12, 332],\n    [24, 32],\n    {\n        value: [24, 32],\n        // label style, only works in this data item.\n        label: {},\n        // item style, only works in this data item.\n        itemStyle:{}\n    },\n    [33, 31]\n]\n</code></pre>\n<p><br>\n<strong>Empty value:</strong></p>\n<p><code class=\"codespan\">&#39;-&#39;</code> or <code class=\"codespan\">null</code> or <code class=\"codespan\">undefined</code> or <code class=\"codespan\">NaN</code> can be used to describe that a data item does not exist (ps：<em>not exist</em> does not means its value is <code class=\"codespan\">0</code>).</p>\n<p>For example, line chart can break when encounter an empty value, and scatter chart do not display graphic elements for empty values.</p>\n<p><br><br></p>\n","items":{"type":"Object","properties":{"symbol":{"type":["string"],"description":"\n\n<p>Symbol of single data.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"},"default":"'circle'"},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>single data symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"},"default":4},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of single data symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of single data symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"inside"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of the specified single data.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state of the specified single data.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<p>Select state of the specified single data.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series data.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}}},"markPoint":{"type":["Object"],"description":"<p>Mark point in a chart.</p>\n","properties":{"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-effectScatter.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'pin'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-effectScatter.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":50},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-effectScatter.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label of mark point.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark point.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Data array for mark points, each of which is an object. Here are some ways to assign mark point position.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-effectScatter.markPoint.data.x\">x</a>, <a href=\"#series-effectScatter.markPoint.data.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li><p>Assign coordinate position with <a href=\"#series-effectScatter.markPoint.data.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</p>\n</li>\n<li><p>Use <a href=\"#series-effectScatter.markPoint.data.type\">type</a> attribute to mark the maximum and minimum values in the series, in which <a href=\"#series-effectScatter.markPoint.data.valueIndex\">valueIndex</a> or <a href=\"#series-effectScatter.markPoint.data.valueDim\">valueDim</a> can be used to assign the dimension.</p>\n</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p><strong>For example: </strong></p>\n<pre><code class=\"lang-js\">data: [\n    {\n        name: &#39;maximum&#39;,\n        type: &#39;max&#39;\n    }, \n    {\n        name: &#39;coordinate&#39;,\n        coord: [10, 20]\n    }, {\n        name: &#39;fixed x position&#39;,\n        yAxis: 10,\n        x: &#39;90%&#39;\n    }, \n\n    {\n        name: &#39;screen coordinate&#39;,\n        x: 100,\n        y: 100\n    }\n]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Mark point name.</p>\n","default":"''"},"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Available when using <a href=\"#series-effectScatter.markPoint.data.type\">type</a> it is used to assign maximum value and minimum value in dimensions, it could be <code class=\"codespan\">0</code> (xAxis, radiusAxis), <code class=\"codespan\">1</code> (yAxis, angleAxis), and use the first value axis dimension by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-effectScatter.markPoint.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markLine":{"type":["Object"],"description":"<p>Use a line in the chart to illustrate.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"symbol":{"type":["string","Array"],"description":"<p>Symbol type at the two ends of the mark line. It can be an array for two ends, or assigned seperately. See <a href=\"#series-effectScatter.markLine.data.0.symbol\">data.symbol</a> for more format information.</p>\n"},"symbolSize":{"type":["number","Array"],"description":"<p>Symbol size at the two ends of the mark line. It can be an array for two ends, or assigned seperately.</p>\n<p><strong>Attention: </strong> You cannot assgin width and height seperately as normal <code class=\"codespan\">symbolSize</code>.</p>\n"},"precision":{"type":["number"],"description":"<p>Precision of marking line value, which is useful when displaying average value mark line.</p>\n","default":2},"label":{"type":["Object"],"description":"<p>Mark line text.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"<p>Mark line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark line.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>Data array of marking line. Every array item can be an array of one or two values, representing starting and ending point of the line, and every item is an object. Here are several ways to assign the positions of starting and ending point.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-effectScatter.markLine.data.0.x\">x</a>, <a href=\"#series-effectScatter.markLine.data.0.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li><p>Assign coordinate position with <a href=\"#series-effectScatter.markLine.data.0.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</p>\n</li>\n<li><p>Use <a href=\"#series-effectScatter.markLine.data.0.type\">type</a> attribute to mark the maximum and minimum values in the series, in which <a href=\"#series-effectScatter.markLine.data.0.valueIndex\">valueIndex</a> or <a href=\"#series-effectScatter.markLine.data.0.valueDim\">valueDim</a> can be used to assign the dimension.</p>\n</li>\n<li><p>You may also create a mark line in Cartesian coordinate at a specific position in X or Y axis by assigning <code class=\"codespan\">xAxis</code> or <code class=\"codespan\">yAxis</code>. See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-weight\" target=\"_blank\">scatter-weight</a> for example.</p>\n</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p>You may also set the type of mark line through <code class=\"codespan\">type</code>, stating whether it is for the maximum value or average value. Likewise, dimensions can be assigned through <code class=\"codespan\">valueIndex</code>.</p>\n<pre><code>data: [\n\n{\n        name: &#39;average line&#39;,\n        // &#39;average&#39;, &#39;min&#39;, and &#39;max&#39; are supported\n        type: &#39;average&#39;\n    },\n    {\n        name: &#39;Horizontal line with Y value at 100&#39;,\n        yAxis: 100\n    },\n    [\n        {\n            // Use the same name with starting and ending point\n            name: &#39;Minimum to Maximum&#39;,\n            type: &#39;min&#39;\n        },\n        {\n            type: &#39;max&#39;\n        }\n    ],\n[\n        {\n            name: &#39;Markline between two points&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [{\n        // Mark line with a fixed X position in starting point. This is used to generate an arrow pointing to maximum line.\n        yAxis: &#39;max&#39;,\n        x: &#39;90%&#39;\n    }, {\n        type: &#39;max&#39;\n    }],\n[\n        {\n            name: &#39;Mark line between two points&#39;,\n            x: 100,\n            y: 100\n        },\n        {\n            x: 500,\n            y: 200\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Data of the starting point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n<li><code class=\"codespan\">&#39;median&#39;</code> median value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-effectScatter.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-effectScatter.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'starting point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of starting point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>starting point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of starting point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of starting point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Data of the ending point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n<li><code class=\"codespan\">&#39;median&#39;</code> median value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-effectScatter.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-effectScatter.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'ending point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of ending point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>ending point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of ending point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of ending point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markArea":{"type":["Object"],"description":"<p>Used to mark an area in chart. For example, mark a time interval.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label in mark area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Style of the mark area.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark area.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>The scope of the area is defined by <code class=\"codespan\">data</code>, which is an array with two item, representing the left-top point and the right-bottom point of rectangle area. Each item can be defined as follows:</p>\n<ol>\n<li>Specify the coordinate in screen coordinate system using <a href=\"#series-effectScatter.markArea.data.0.x\">x</a>, <a href=\"#series-effectScatter.markArea.data.0.y\">y</a>, where the unit is pixel (e.g., the value is <code class=\"codespan\">5</code>), or percent (e.g., the value is <code class=\"codespan\">&#39;35%&#39;</code>).</li>\n</ol>\n<ol start=\"2\">\n<li><p>Specify the coordinate in data coordinate system (i.e., cartesian) using\n<a href=\"#series-effectScatter.markArea.data.0.coord\">coord</a>, which can be also set as <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> (e.g, <code class=\"codespan\">coord: [23, &#39;min&#39;]</code>, or <code class=\"codespan\">coord: [&#39;average&#39;, &#39;max&#39;]</code>).</p>\n</li>\n<li><p>Locate the point on the min value or max value of <code class=\"codespan\">series.data</code> using <a href=\"#series-effectScatter.markArea.data.0.type\">type</a>, where <a href=\"#series-effectScatter.markArea.data.0.valueIndex\">valueIndex</a> or <a href=\"#series-effectScatter.markPoint.data.0.valueDim\">valueDim</a> can be used to specify the dimension on which the min, max or average are calculated.</p>\n</li>\n<li>If in cartesian, you can only specify <code class=\"codespan\">xAxis</code> or <code class=\"codespan\">yAxis</code> to define a mark area based on only X or Y axis, see sample <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-weight\" target=\"_blank\">scatter-weight</a></li>\n</ol>\n<p>The priority follows as above if more than one above definition used.</p>\n<pre><code>data: [\n\n\n    [\n        {\n            name: &#39;From average to max&#39;,\n            type: &#39;average&#39;\n        },\n        {\n            type: &#39;max&#39;\n        }\n    ],\n\n    [\n        {\n            name: &#39;Mark area between two points in data coordiantes&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [\n        {\n            name: &#39;From 60 to 80&#39;,\n            yAxis: 60\n        },\n        {\n            yAxis: 80\n        }\n    ], [\n        {\n            name: &#39;Mark area covers all data&#39;\n            coord: [&#39;min&#39;, &#39;min&#39;]\n        },\n        {\n            coord: [&#39;max&#39;, &#39;max&#39;]\n        }\n    ],\n[\n        {\n            name: &#39;Mark area in two screen points&#39;,\n            x: 100,\n            y: 100\n        }, {\n            x: &#39;90%&#39;,\n            y: &#39;10%&#39;\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Specify the left-top point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Specify this item is on min or max or average value.</p>\n<p><strong>Options:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> max value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> min value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-effectScatter.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-effectScatter.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'start'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Specify the right-bottom point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Specify this item is on min or max or average value.</p>\n<p><strong>Options:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> max value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> min value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-effectScatter.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-effectScatter.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'end'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"false","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p><strong>radar chart</strong></p>\n<p>Radar chart is mainly used to show multi-variable data, such as the analysis of a football player&#39;s varied attributes. It relies <a href=\"#radar\">radar</a> component.</p>\n<p>Here is the example of AQI data which is presented in radar chart.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=radar-aqi&edit=1&reset=1\" width=\"600\" height=\"500\"></iframe>\n\n","properties":{"type":{"type":["string"],"description":"","default":"'radar'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"radarIndex":{"type":["number"],"description":"<p>Index of <a href=\"#radar\">radar</a> component that radar chart uses.</p>\n"},"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-radar.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'circle'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-radar.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":4},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-radar.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"label":{"type":["Object"],"description":"<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'top'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"itemStyle":{"type":["Object"],"description":"<p>Item style of the inflection point of the lines.</p>\n","properties":{"color":{"type":["Color","Function"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n<p>Supports callback functions, in the form of:</p>\n<pre><code class=\"lang-js\">(params: Object) =&gt; Color\n</code></pre>\n<p>Input parameters are <code class=\"codespan\">seriesIndex</code>, <code class=\"codespan\">dataIndex</code>, <code class=\"codespan\">data</code>, <code class=\"codespan\">value</code>, and etc. of data item.</p>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"lineStyle":{"type":["Object"],"description":"<p>Line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"areaStyle":{"type":["Object"],"description":"<p>Area filling style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"areaStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Available when <a href=\"#series-radar.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"areaStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of select state. Available when <a href=\"#series-radar.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"areaStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"data":{"type":["Array"],"description":"<p>The data in radar chart is multi-variable (dimension). Here is an example:</p>\n<pre><code class=\"lang-js\">data : [\n    {\n        value : [4300, 10000, 28000, 35000, 50000, 19000],\n        name : &#39;Allocated Budget&#39;\n    },\n    {\n        value : [5000, 14000, 28000, 31000, 42000, 21000],\n        name : &#39;Actual Spending&#39;\n    }\n]\n</code></pre>\n<p>Among them, <code class=\"codespan\">value</code> item array contains data that is corresponding to <a href=\"#radar.indicator\">radar.indicator</a>.</p>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Data item name</p>\n"},"value":{"type":["number"],"description":"<p>Numerical value of a single data item.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of single data.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"},"default":"'circle'"},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>single data symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"},"default":4},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of single data symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of single data symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"label":{"type":["Object"],"description":"<p>Style setting of the text on single inflection point.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"top"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Style setting of the symbol on single inflection point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"<p>Line style of a single item.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"areaStyle":{"type":["Object"],"description":"<p>Area filling style of a single item.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"areaStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"areaStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of selected state.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"areaStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series data.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in Radar.</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in Radar, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p><strong>Tree Diagram</strong></p>\n<p>The tree diagram is mainly used to visualize the tree data structure, which is a special hierarchical type with a unique root node, left subtree, and right subtree.</p>\n<p><strong>Note: Forests are not currently supported directly in a single series, and can be implemented by configuring multiple series in an option</strong></p>\n<p><strong>Tree example：</strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=tree-vertical&edit=1&reset=1\" width=\"900\" height=\"780\"></iframe>\n\n\n<p><strong>Multiple series are combined into forest：</strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=tree-legend&edit=1&reset=1\" width=\"800\" height=\"680\"></iframe>\n\n","properties":{"type":{"type":["string"],"description":"","default":"'tree'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between tree component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"12%"},"top":{"type":["string","number"],"description":"<p>Distance between tree component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"12%"},"right":{"type":["string","number"],"description":"<p>Distance between tree component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":"12%"},"bottom":{"type":["string","number"],"description":"<p>Distance between tree component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":"12%"},"width":{"type":["string","number"],"description":"<p>Width of tree component. </p>\n","default":null},"height":{"type":["string","number"],"description":"<p>Height of tree component. </p>\n","default":null},"layout":{"type":["string"],"description":"\n\n<p>The layout of the tree, which can be <code class=\"codespan\">orthogonal</code> and <code class=\"codespan\">radial</code>. Here the <code class=\"codespan\">orthogonal</code> layout is what we usually refer to the <code class=\"codespan\">horizontal</code> and <code class=\"codespan\">vertical</code> direction, the corresponding parameter value is <code class=\"codespan\">orthogonal</code>. The <code class=\"codespan\">radial</code> layout refers to the view that the root node as the center and each layer of nodes as the ring, the corresponding parameter value is <code class=\"codespan\">radial</code>.</p>\n<p><strong>Orthogonal Example：</strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=tree-basic&edit=1&reset=1\" width=\"780\" height=\"900\"></iframe>\n\n\n\n<p><strong>Radial Example：</strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=tree-radial&edit=1&reset=1\" width=\"800\" height=\"800\"></iframe>\n\n","uiControl":{"type":"enum","options":"orthogonal,radial","default":"orthogonal"},"default":"'orthogonal'"},"orient":{"type":["string"],"description":"\n\n<p>The direction of the <code class=\"codespan\">orthogonal</code> layout in the tree diagram. That means this configuration takes effect only if <code class=\"codespan\">layout = &#39;orthogonal&#39;</code>. The corresponding directions are <code class=\"codespan\">from left to right</code>, <code class=\"codespan\">from right to left</code>, <code class=\"codespan\">from top to bottom</code>, <code class=\"codespan\">from bottom to top</code>, with shorthand values <code class=\"codespan\">&#39;LR&#39;</code>, <code class=\"codespan\">&#39;RL&#39;</code>, <code class=\"codespan\">&#39;TB&#39;</code>, <code class=\"codespan\">&#39;BT&#39;</code>.\n<strong>Note: The previous configuration value <code class=\"codespan\">&#39;horizontal&#39;</code> is equivalent to <code class=\"codespan\">&#39;LR&#39;</code>, <code class=\"codespan\">&#39;vertical&#39;</code> is equivalent to <code class=\"codespan\">&#39;TB&#39;</code>.</strong></p>\n","uiControl":{"type":"enum","options":"LR,RL,TB,BT","default":"LR"},"default":"'LR'"},"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-tree.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'emptyCircle'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-tree.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":7},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-tree.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"edgeShape":{"type":["string"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v4.7.0</code></p>\n</blockquote>\n<p>The shape of the edge which is under the tree <code class=\"codespan\">orthogonal layout</code>. There are two types of shape, curve and polyline, the corresponding values are <code class=\"codespan\">&#39;curve&#39;</code> and <code class=\"codespan\">&#39;polyline&#39;</code>.</p>\n<p><strong> Note: This configuration item is only valid under the <code class=\"codespan\">orthogonal layout</code>. Errors will be reported in the development environment under the <code class=\"codespan\">radial layout</code>. </strong></p>\n","uiControl":{"type":"enum","options":"curve,polyline","default":"curve"},"default":"'curve'"},"edgeForkPosition":{"type":["string"],"description":"\n\n<p>This is the position where the polyline branches in the subtree when the shape of the edge is a polyline in the <code class=\"codespan\">orthogonal layout</code>. The position here refers to the percentage of the distance between the bifurcation point and the parent node of the subtree to the height of the entire subtree. The default value is <code class=\"codespan\">&#39;50%&#39;</code>, which can be between [&#39;0&#39;, &#39;100%&#39;].</p>\n<p><strong> Note: This configuration item is only valid when <code class=\"codespan\">edgeShape = &#39;polyline&#39;</code>. </strong></p>\n","uiControl":{"type":"percent","default":"50%"},"default":"'50%'"},"roam":{"type":["boolean","string"],"description":"\n\n<p>Whether to enable mouse zooming and translating. <code class=\"codespan\">false</code> by default. If either zooming or translating is wanted, it can be set to <code class=\"codespan\">&#39;scale&#39;</code> or <code class=\"codespan\">&#39;move&#39;</code>. Otherwise, set it to be <code class=\"codespan\">true</code> to enable both.</p>\n","uiControl":{"type":"enum","options":"true,false,scale,move"},"default":false},"expandAndCollapse":{"type":["boolean"],"description":"\n\n<p>Subtree collapses and expands interaction, <code class=\"codespan\">default true</code>. As the drawing area is limited, and usually the nodes of a tree may be more, so there will be hidden between the nodes. In order to avoid this problem, you can put a temporary unrelated subtree folded away, until you need to start when necessary. Such as the above radial layout tree example, the center of the node is filled with blue is the folded away subtree, you can click to expand it.</p>\n<p><strong>Note: If you configure a custom image as the tag for a node, it is not possible to distinguish whether the current node has a collapsed subtree by the fill color. And currently do not support, upload two pictures, respectively represent the collapsing and expansion state of the node. So, if you want to explicitly show the two states of the node, it is recommended to use <code class=\"codespan\">ECharts</code> regular tag types, such as <code class=\"codespan\">emptyCircle</code>.</strong></p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"initialTreeDepth":{"type":["number"],"description":"\n\n<p>The initial level (depth) of the tree. The root node is the 0th layer, then the first layer, the second layer, ... , until the leaf node. This configuration item is primarily used in conjunction with <code class=\"codespan\">collapsing and expansion</code> interactions. The purpose is to prevent the nodes from obscuring each other. If set as -1 or <code class=\"codespan\">null</code> or <code class=\"codespan\">undefined</code>, all nodes are expanded.</p>\n","uiControl":{"type":"number","default":"2","min":"0","step":"1"},"default":2},"itemStyle":{"type":["Object"],"description":"<p>The style of each node in the tree, where <a href=\"#series-tree.itemStyle.color\">itemStyle.color</a> represents the fill color of the node, to distinguish the state of the subtree corresponding to <code class=\"codespan\">collapsing</code> or <code class=\"codespan\">expansion</code>.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#c23531'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1.5","min":"0","step":"0.5"},"default":1.5},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> describes the style of the text corresponding to each node.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"lineStyle":{"type":["Object"],"description":"<p>Defines the style of the tree edge.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of the tree edge.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"width":{"type":["number"],"description":"\n\n<p>The width of the tree edge.</p>\n","uiControl":{"type":"number","default":"1.5","min":"0"},"default":1.5},"curveness":{"type":["number"],"description":"\n\n<p>The curvature of the tree edge.</p>\n","uiControl":{"type":"number","default":"0.5","min":"0"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"emphasis":{"type":["Object"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<ul>\n<li><code class=\"codespan\">&#39;ancestor&#39;</code> Focus on all ancestor nodes.</li>\n<li><code class=\"codespan\">&#39;descendant&#39;</code> Focus on all descendants nodes.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"itemStyle":{"type":["Object"],"description":"<p>该节点的样式。</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"<p>Defines the style of the tree edge.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of the tree edge.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"width":{"type":["number"],"description":"\n\n<p>The width of the tree edge.</p>\n","uiControl":{"type":"number","default":"1.5","min":"0"},"default":1.5},"curveness":{"type":["number"],"description":"\n\n<p>The curvature of the tree edge.</p>\n","uiControl":{"type":"number","default":"0.5","min":"0"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Available when <a href=\"#series-tree.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"<p>该节点的样式。</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"<p>Defines the style of the tree edge.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of the tree edge.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"width":{"type":["number"],"description":"\n\n<p>The width of the tree edge.</p>\n","uiControl":{"type":"number","default":"1.5","min":"0"},"default":1.5},"curveness":{"type":["number"],"description":"\n\n<p>The curvature of the tree edge.</p>\n","uiControl":{"type":"number","default":"0.5","min":"0"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of select state. Available when <a href=\"#series-tree.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"<p>该节点的样式。</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"<p>Defines the style of the tree edge.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of the tree edge.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"width":{"type":["number"],"description":"\n\n<p>The width of the tree edge.</p>\n","uiControl":{"type":"number","default":"1.5","min":"0"},"default":1.5},"curveness":{"type":["number"],"description":"\n\n<p>The curvature of the tree edge.</p>\n","uiControl":{"type":"number","default":"0.5","min":"0"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"leaves":{"type":["Object"],"description":"<p>Leaf node special configuration, such as the above tree diagram example, the leaf node and non-leaf node label location is different.</p>\n","properties":{"label":{"type":["Object"],"description":"<p>Describes the style of the text label corresponding to the leaf node.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>The style of the leaf node in the tree.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of leaves nodes.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"<p>该节点的样式。</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"<p>Defines the style of the tree edge.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of the tree edge.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"width":{"type":["number"],"description":"\n\n<p>The width of the tree edge.</p>\n","uiControl":{"type":"number","default":"1.5","min":"0"},"default":1.5},"curveness":{"type":["number"],"description":"\n\n<p>The curvature of the tree edge.</p>\n","uiControl":{"type":"number","default":"0.5","min":"0"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state of leaves nodes.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"<p>该节点的样式。</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"<p>Defines the style of the tree edge.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of the tree edge.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"width":{"type":["number"],"description":"\n\n<p>The width of the tree edge.</p>\n","uiControl":{"type":"number","default":"1.5","min":"0"},"default":1.5},"curveness":{"type":["number"],"description":"\n\n<p>The curvature of the tree edge.</p>\n","uiControl":{"type":"number","default":"0.5","min":"0"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state of leaves nodes.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"<p>该节点的样式。</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"<p>Defines the style of the tree edge.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of the tree edge.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"width":{"type":["number"],"description":"\n\n<p>The width of the tree edge.</p>\n","uiControl":{"type":"number","default":"1.5","min":"0"},"default":1.5},"curveness":{"type":["number"],"description":"\n\n<p>The curvature of the tree edge.</p>\n","uiControl":{"type":"number","default":"0.5","min":"0"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"data":{"type":["Object"],"description":"<p><a href=\"#series-tree.data\">series-tree.data</a> the data format is a tree structure, for example：</p>\n<pre><code class=\"lang-javascript\">{ // note that the outermost layer is an object that represents the root node of the tree.\n    name: &quot;flare&quot;,    // the name of the node, the text corresponding to the current node label.\n    label: {          // the special label configuration (if necessary).\n        ...           // the format of the label is shown in the series-tree.label.\n    },\n    itemStyle: {      // the special itemStyle configuration (if necessary).\n        ...           // the format of the itemstyle is shown in the series-tree.itemStyle.\n    },\n    children: [\n        {\n            name: &quot;flex&quot;,\n            value: 4116,    // value, which only displayed in tooltip.\n            label: {\n                ...\n            },\n            itemStyle: {\n                ...\n            },\n            collapsed: null, // If set as `true`, the node is collpased in the initialization.\n            children: [...]  // leaf nodes do not have children, can not write.\n        },\n        ...\n    ]\n};\n</code></pre>\n","properties":{"name":{"type":["string"],"description":"<p>The name of the tree node, used to identify each node.</p>\n"},"value":{"type":["number"],"description":"<p>The value of the node, displayed in the tooltip.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>The style of the node.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"<p>Defines the style of the tree edge.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of the tree edge.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"width":{"type":["number"],"description":"\n\n<p>The width of the tree edge.</p>\n","uiControl":{"type":"number","default":"1.5","min":"0"},"default":1.5},"curveness":{"type":["number"],"description":"\n\n<p>The curvature of the tree edge.</p>\n","uiControl":{"type":"number","default":"0.5","min":"0"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"label":{"type":["Object"],"description":"<p>The label of the node.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of a single node.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"<p>该节点的样式。</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"<p>Defines the style of the tree edge.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of the tree edge.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"width":{"type":["number"],"description":"\n\n<p>The width of the tree edge.</p>\n","uiControl":{"type":"number","default":"1.5","min":"0"},"default":1.5},"curveness":{"type":["number"],"description":"\n\n<p>The curvature of the tree edge.</p>\n","uiControl":{"type":"number","default":"0.5","min":"0"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state of a single node.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"<p>该节点的样式。</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"<p>Defines the style of the tree edge.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of the tree edge.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"width":{"type":["number"],"description":"\n\n<p>The width of the tree edge.</p>\n","uiControl":{"type":"number","default":"1.5","min":"0"},"default":1.5},"curveness":{"type":["number"],"description":"\n\n<p>The curvature of the tree edge.</p>\n","uiControl":{"type":"number","default":"0.5","min":"0"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state of a single node.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"<p>该节点的样式。</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"<p>Defines the style of the tree edge.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of the tree edge.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"width":{"type":["number"],"description":"\n\n<p>The width of the tree edge.</p>\n","uiControl":{"type":"number","default":"1.5","min":"0"},"default":1.5},"curveness":{"type":["number"],"description":"\n\n<p>The curvature of the tree edge.</p>\n","uiControl":{"type":"number","default":"0.5","min":"0"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series data.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"'linear'"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p><a href=\"https://en.wikipedia.org/wiki/Treemapping\" target=\"_blank\">Treemap</a> is a common way to present &quot;hierarchical data&quot; or &quot;tree data&quot;. It primarily highlights the important nodes at all hierarchies in 『Tree』with area.</p>\n<p><strong>Example:</strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=treemap-obama&edit=1&reset=1\" width=\"700\" height=\"580\"></iframe>\n\n\n\n\n<p><strong>Visual Mapping:</strong></p>\n<p>treemap maps the numerical values to area.</p>\n<p>Moreover, it is able to map some dimensions of data to other visual channel, like colors, lightness of colors and etc.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<p><strong>Drill Down:</strong></p>\n<p>The feature <code class=\"codespan\">drill down</code> means: when clicking a tree node, this node will be set as root and its children will be shown. When <a href=\"#series-treemap.leafDepth\">leafDepth</a> is set, this feature is enabled.</p>\n<p><strong>An example about drill down:</strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=treemap-drill-down&edit=1&reset=1\" width=\"800\" height=\"500\"></iframe>\n\n\n\n<p>Notice: There are some difference in treemap configuration between ECharts3 and ECharts2. Some immature configuration ways are no longer supported:</p>\n<ul>\n<li><p>The position method using <code class=\"codespan\">center/size</code> is no longer supported, and <code class=\"codespan\">left/top/bottom/right/width/height</code> are used to position treemap, as other components do.</p>\n</li>\n<li><p>The configuration item <code class=\"codespan\">breadcrumb</code> is moved outside <code class=\"codespan\">itemStyle/itemStyle.emphasis</code>, and it is in the same level with <code class=\"codespan\">itemStyle</code> now.</p>\n</li>\n<li><p>The configuration item <code class=\"codespan\">root</code> is not avaliable temporarily.User can zoom treemap to see some tiny or deep descendants, or using <a href=\"#series-treemap.leafDepth\">leafDepth</a> to enable the feature of &quot;drill down&quot;.</p>\n</li>\n<li><p>The configuration item <code class=\"codespan\">label</code> is moved outside the <code class=\"codespan\">itemStyle/itemStyle.emphasis</code>, and it is in the same level with <code class=\"codespan\">itemStyle</code> now.</p>\n</li>\n<li><p>The configuration items <code class=\"codespan\">itemStyle.childBorderWidth</code> and <code class=\"codespan\">itemStyle.childBorderColor</code> are not supported anymore (because in this way only 2 levels can be defined). <a href=\"#series-treemap.levels\">series-treemap.levels</a> is used to define all levels now.</p>\n</li>\n</ul>\n","properties":{"type":{"type":["string"],"description":"","default":"'treemap'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between treemap  component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"center"},"top":{"type":["string","number"],"description":"<p>Distance between treemap  component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"middle"},"right":{"type":["string","number"],"description":"<p>Distance between treemap  component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"bottom":{"type":["string","number"],"description":"<p>Distance between treemap  component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"width":{"type":["string","number"],"description":"<p>Width of treemap  component. </p>\n","default":"80%"},"height":{"type":["string","number"],"description":"<p>Height of treemap  component. </p>\n","default":"80%"},"squareRatio":{"type":["number"],"description":"\n\n<p>The expected square ratio. Layout would approach the ratio as close as possible.</p>\n<p>It defaults to be the golden ratio: <code class=\"codespan\">0.5 * (1 + Math.sqrt(5))</code>.</p>\n","uiControl":{"type":"number","min":"0.1","default":"0.75","step":"0.1"}},"leafDepth":{"type":["number"],"description":"\n\n<p>When <code class=\"codespan\">leafDepth</code> is set, the feature &quot;drill down&quot; is enabled, which means when clicking a tree node, this node will be set as root and its children will be shown.</p>\n<p><code class=\"codespan\">leafDepth</code> represents how many levels are shown at most. For example, when <code class=\"codespan\">leafDepth</code> is set to <code class=\"codespan\">1</code>, only one level will be shown.</p>\n<p><code class=\"codespan\">leafDepth</code> is <code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code> by default, which means that &quot;drill down&quot; is disabled.</p>\n<p><strong>An example about drill down:</strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=treemap-drill-down&edit=1&reset=1\" width=\"800\" height=\"500\"></iframe>\n\n","uiControl":{"type":"number","min":"1","step":"1"},"default":null},"drillDownIcon":{"type":["string"],"description":"<p>Marker when the node is able to be drilled down.</p>\n","default":"'▶'"},"roam":{"type":["boolean","string"],"description":"<p>Whether to enable dragging roam (move and zoom). Optional values are:</p>\n<ul>\n<li><code class=\"codespan\">false</code>: roam is disabled.</li>\n<li><code class=\"codespan\">&#39;scale&#39;</code> or <code class=\"codespan\">&#39;zoom&#39;</code>: zoom only.</li>\n<li><code class=\"codespan\">&#39;move&#39;</code> or <code class=\"codespan\">&#39;pan&#39;</code>: move (translation) only.</li>\n<li><code class=\"codespan\">true</code>: both zoom and move (translation) are avaliable.</li>\n</ul>\n","default":true},"nodeClick":{"type":["boolean","string"],"description":"<p>The behaviour when clicking a node. Optional values are:</p>\n<ul>\n<li><code class=\"codespan\">false</code>: Do nothing after clicked.</li>\n<li><code class=\"codespan\">&#39;zoomToNode&#39;</code>: Zoom to clicked node.</li>\n<li><code class=\"codespan\">&#39;link&#39;</code>: If there is <a href=\"#series-treemap.data.link\">link</a> in node data, do hyperlink jump after clicked.</li>\n</ul>\n","default":"'zoomToNode'"},"zoomToNodeRatio":{"type":["number"],"description":"\n\n<p>The treemap will be auto zoomed to a appropriate ratio when a node is clicked (when <a href=\"#series-treemap.nodeClick\">nodeClick</a> is set as <code class=\"codespan\">&#39;zoomToNode&#39;</code> and no drill down happens). This configuration item indicates the ratio.</p>\n","uiControl":{"type":"number","min":"0","default":"0.1","step":"0.01"},"default":"0.32*0.32"},"visualDimension":{"type":["number"],"description":"<p><code class=\"codespan\">treemap</code> is able to map any dimensions of data to visual.</p>\n<p>The value of <a href=\"#series-treemap.data\">series-treemap.data</a> can be an array. And each item of the array represents a &quot;dimension&quot;. <code class=\"codespan\">visualDimension</code> specifies the dimension on which visual mapping will be performed.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">visualDimension</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","default":0},"visualMin":{"type":["number"],"description":"\n\n<p>The minimal value of current level. Auto-statistics by default.</p>\n<p>When <a href=\"#series-treemap.levels.colorMappingBy\">colorMappingBy</a> is set to <code class=\"codespan\">&#39;value&#39;</code>, you are able to specify extent manually for visual mapping by specifying <code class=\"codespan\">visualMin</code> or <code class=\"codespan\">visualMax</code>.</p>\n","uiControl":{"type":"number","default":"0"},"default":null},"visualMax":{"type":["number"],"description":"\n\n<p>The maximal value of current level. Auto-statistics by default.</p>\n<p>When <a href=\"#series-treemap.levels.colorMappingBy\">colorMappingBy</a> is set to <code class=\"codespan\">&#39;value&#39;</code>, you are able to specify extent manually for visual mapping by specifying <code class=\"codespan\">visualMin</code> or <code class=\"codespan\">visualMax</code>.</p>\n","uiControl":{"type":"number","default":"100"},"default":null},"colorAlpha":{"type":["Array"],"description":"<p>It indicates the range of tranparent rate (color alpha) for nodes of the series</p>\n<p>.\nThe range of values is 0 ~ 1.</p>\n<p>For example, <code class=\"codespan\">colorAlpha</code> can be <code class=\"codespan\">[0.3, 1]</code>.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">colorAlpha</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","default":null},"colorSaturation":{"type":["number"],"description":"<p>It indicates the range of saturation (color alpha) for nodes  of the series.</p>\n<p>The range of values is 0 ~ 1.</p>\n<p>For example, <code class=\"codespan\">colorSaturation</code> can be <code class=\"codespan\">[0.3, 1]</code>.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">colorSaturation</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","default":null},"colorMappingBy":{"type":["string"],"description":"\n\n<p>Specify the rule according to which each node obtain color from <a href=\"#series-treemap.levels.color\">color list</a>. Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;value&#39;</code>:</li>\n</ul>\n<p>Map <a href=\"#series-treemap.data.value\">series-treemap.data.value</a> to color.</p>\n<p>In this way, the color of each node indicate its value.</p>\n<p><a href=\"#series-treemap.levels.visualDimension\">visualDimension</a> can be used to specify which dimension of <a href=\"#series-treemap.data\">data</a> is used to perform visual mapping.</p>\n<ul>\n<li><code class=\"codespan\">&#39;index&#39;</code>:</li>\n</ul>\n<p>Map the <code class=\"codespan\">index</code> (ordinal number) of nodes to color. Namely, in a level, the first node is mapped to the first color of <a href=\"#series-treemap.levels.color\">color list</a>, and the second node gets the second color.</p>\n<p>In this way, adjacent nodes are distinguished by color.</p>\n<ul>\n<li><code class=\"codespan\">&#39;id&#39;</code>:</li>\n</ul>\n<p>Map <a href=\"#series-treemap.data.id\">series-treemap.data.id</a> to color.</p>\n<p>Since <code class=\"codespan\">id</code> is used to identify node, if user call <code class=\"codespan\">setOption</code> to modify the tree, each node will remain the original color before and after <code class=\"codespan\">setOption</code> called. See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=treemap-obama&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">colorMappingBy</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","uiControl":{"type":"enum","options":"index,value,id"},"default":"'index'"},"visibleMin":{"type":["number"],"description":"\n\n<p>A node will not be shown when its area size is smaller than this value (unit: px square).</p>\n<p>In this way, tiny nodes will be hidden, otherwise they will huddle together. When user zoom the treemap, the area size will increase and the rectangle will be shown if the area size is larger than this threshold.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">visibleMin</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","uiControl":{"type":"number","default":"10","min":"0"},"default":10},"childrenVisibleMin":{"type":["number"],"description":"\n\n<p>Children will not be shown when area size of a node is smaller than this value (unit: px square).</p>\n<p>This can hide the details of nodes when the rectangular area is not large enough. When users zoom nodes, the child node would show if the area is larger than this threshold.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">childrenVisibleMin</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","uiControl":{"type":"number","default":"10","min":"0","step":"0.5"},"default":null},"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> decribes the style of the label in each node.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">label</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"upperLabel":{"type":["Object"],"description":"<p><code class=\"codespan\">upperLabel</code> is used to specify whether show label when the node has children. When <a href=\"#series-treemap.upperLabel.show\">upperLabel.show</a> is set as <code class=\"codespan\">true</code>, the feature that &quot;show parent label&quot; is enabled.</p>\n<p>The same as <a href=\"#series-treemap.label\">series-treemap.label</a>, the option <code class=\"codespan\">upperLabel</code> can be placed at the root of <a href=\"#series-treemap\">series-treemap</a> directly, or in <a href=\"#series-treemap.level\">series-treemap.level</a>, or in each item of <a href=\"#series-treemap.data\">series-treemap.data</a>.</p>\n<p>Specifically, <a href=\"#series-treemap.label\">series-treemap.label</a> specifies the style when a node is a leaf, while <code class=\"codespan\">upperLabel</code> specifies the style when a node has children, in which case the label is displayed in the inner top of the node.</p>\n<p>See:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=treemap-show-parent&edit=1&reset=1\" width=\"700\" height=\"500\"></iframe>\n\n\n\n\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">label</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of label area.</p>\n","uiControl":{"type":"number","default":"20","min":"0","step":"0.5"},"default":20},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">itemStyle</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of a node. It use global palette <a href=\"#color\">option.color</a> by default.</p>\n","uiControl":{"type":"color"},"default":null},"colorAlpha":{"type":["number"],"description":"\n\n<p>The tranparent rate of a node, the range is between 0 ~ 1.</p>\n","uiControl":{"type":"number","step":"0.01","min":"0","max":"1","default":"1"},"default":null},"colorSaturation":{"type":["number"],"description":"\n\n<p>The color saturation of a node. The range is between 0 ~ 1.</p>\n","uiControl":{"type":"number","step":"0.01","min":"0","max":"1","default":"0.5"},"default":null},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>Border radius.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB","clean":"true"},"default":0},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of a node. There is no border when it is set as <code class=\"codespan\">0</code>.</p>\n<p>Tip, gaps between child nodes are specified by <a href=\"#series-treemap.levels.gapWidth\">gapWidth</a></p>\n","uiControl":{"type":"number","step":"0.5","min":"0"},"default":0},"gapWidth":{"type":["number"],"description":"\n\n<p>Gaps between child nodes.</p>\n","uiControl":{"type":"number","step":"0.5","min":"0"},"default":0},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color and gap color of a node.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'#fff',"},"borderColorSaturation":{"type":["Color"],"description":"\n\n<p>The color saturation of a border or gap. The value range is between 0 ~ 1.</p>\n<p>Tips:</p>\n<p>When <code class=\"codespan\">borderColorSaturation</code> is set, the <code class=\"codespan\">borderColor</code> is disabled, and, instead, the final border color is calculated based on the color of this node (this color could be sepcified explicitly or inherited from its parent node) and mixing with <code class=\"codespan\">borderColorSaturation</code>.</p>\n<p>In this way, a effect can be implemented: different sections have different hue of gap color repectively, which makes users easy to distinguish both sections and levels.</p>\n<p><strong>How to avoid confusion by setting border/gap of node</strong></p>\n<p>If all of the border/gaps are set with the same color, confusion might occur when rectangulars in different levels display at the same time.</p>\n<p>See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/treemap-borderColor&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>. Notice that the child rectangles in the red area are in the deeper level than rectangles that are saparated by white gap. So in the red area, basically we set gap color with red, and use <code class=\"codespan\">borderColorSaturation</code> to lift the saturation.</p>\n","uiControl":{"type":"number","step":"0.01","min":"0","max":"1","default":"0.5"},"default":null},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<ul>\n<li><code class=\"codespan\">&#39;ancestor&#39;</code> Focus on all ancestor nodes.</li>\n<li><code class=\"codespan\">&#39;descendant&#39;</code> Focus on all descendants nodes.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"upperLabel":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of a node. It use global palette <a href=\"#color\">option.color</a> by default.</p>\n","uiControl":{"type":"color"},"default":null}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"upperLabel":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of a node. It use global palette <a href=\"#color\">option.color</a> by default.</p>\n","uiControl":{"type":"color"},"default":null}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"upperLabel":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of a node. It use global palette <a href=\"#color\">option.color</a> by default.</p>\n","uiControl":{"type":"color"},"default":null}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"breadcrumb":{"type":["Object"],"description":"<p>breadcrumb, showing the path of the current node.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the breadcrumb.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"left":{"type":["string","number"],"description":"<p>Distance between asdf  component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'center'"},"top":{"type":["string","number"],"description":"<p>Distance between asdf  component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'auto'"},"right":{"type":["string","number"],"description":"<p>Distance between asdf  component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"bottom":{"type":["string","number"],"description":"<p>Distance between asdf  component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":0},"height":{"type":["number"],"description":"\n\n<p>The height of breadcrumb.</p>\n","uiControl":{"type":"number","min":"0","default":"22","step":"1"},"default":22},"emptyItemWidth":{"type":["number"],"description":"\n\n<p>When is no content in breadcrumb, this minimal width need to be set up.</p>\n","uiControl":{"type":"number","min":"0","default":"25","step":"1"},"default":25},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of , <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>boxplot color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"rgba(0,0,0,0.7)"},"borderColor":{"type":["Color"],"description":"\n\n<p>boxplot border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"rgba(255,255,255,0.7)"},"borderWidth":{"type":["number"],"description":"\n\n<p>boxplot border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"rgba(150,150,150,1)"},"default":"rgba(150,150,150,1)"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"textStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"#fff"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"emphasis":{"type":["*"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>boxplot color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"rgba(0,0,0,0.7)"},"borderColor":{"type":["Color"],"description":"\n\n<p>boxplot border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"rgba(255,255,255,0.7)"},"borderWidth":{"type":["number"],"description":"\n\n<p>boxplot border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"3","min":"0","step":"0.5"},"default":3},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"rgba(150,150,150,1)"},"default":"rgba(150,150,150,1)"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"textStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"#fff"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"levels":{"type":["Array"],"description":"<p><strong>Multiple Levels Configuration</strong></p>\n<p>treemap adopts 4-level configuration:</p>\n<pre><code>&quot;each node&quot; --&gt; &quot;each level&quot; --&gt; &quot;each series&quot;.\n</code></pre><p>That is, we can configurate each node, can also configurate each level of the tree, or set overall configurations on each series. The highest priority is node configuration.</p>\n<p><code class=\"codespan\">levels</code> is configurations on each levels, which is used most.</p>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">// Notice that in fact the data structure is not &quot;tree&quot;, but is &quot;forest&quot;.\ndata: [\n    {\n        name: &#39;nodeA&#39;,\n        children: [\n            {name: &#39;nodeAA&#39;},\n            {name: &#39;nodeAB&#39;},\n        ]\n    },\n    {\n        name: &#39;nodeB&#39;,\n        children: [\n            {name: &#39;nodeBA&#39;}\n        ]\n    }\n],\nlevels: [\n    {...}, // configurations of the top level of the data structure &quot;forest&quot;\n        // (the level that contains &#39;nodeA&#39;, &#39;nodeB&#39; shown above).\n    {...}, // configurations of the next level\n        // (the level that contains &#39;nodeAA&#39;, &#39;nodeAB&#39;, &#39;nodeBA&#39; shown above)\n    {...}, // configurations of the next level\n    ...\n]\n</code></pre>\n<p><strong>The Rules about Visual Mapping</strong></p>\n<p>When designing a treemap, we primarily focus on how to visually distinguish &quot;different levels&quot;, &quot;different categories in the same level&quot;, which requires appropriate settings of &quot;rectangular color&quot;, &quot;border thickness&quot;, &quot;border color&quot; and even &quot;color saturation of rectangular&quot; and so on on each level.</p>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=treemap-disk&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>. The top level is divided into several parts by colors &quot;red&quot;, &quot;green&quot;, &quot;blue&quot;, and etc ... In each color block, <code class=\"codespan\">colorSaturation</code> is used to distinguish nodes in sublevel. The border color of the top level is &quot;white&quot;, while the border color of the sublevel is the color that based on the current block color and processed by <code class=\"codespan\">borderColorSaturation</code>.</p>\n<p><code class=\"codespan\">treemap</code> uses this rule of visual configuration: each level computes its visual value based on the configurations (<code class=\"codespan\">color</code>, <code class=\"codespan\">colorSaturation</code>, <code class=\"codespan\">borderColor</code>, <code class=\"codespan\">borderColorSaturation</code>) on this level. If there is no certain configuration in a node, it inherits the configuration from its parent.</p>\n<p>In this way, this effect can be configured: set a <code class=\"codespan\">color</code> list on the parent level, and set <code class=\"codespan\">colorSaturation</code> on the child level, and then each node in the parent level would obtain a color from the <code class=\"codespan\">color</code> list, and each node in the child level would obtain a value from <code class=\"codespan\">colorSaturation</code> and compound it with the color inherited from its parent node to get its final color.</p>\n<p><strong>Dimensions and &quot;Extra Visual Mapping&quot;</strong></p>\n<p>See the example below: every <code class=\"codespan\">value</code> field is set as an Array, in which each item in the array represents a dimension respectively.</p>\n<pre><code class=\"lang-javascript\">[\n    {\n        value: [434, 6969, 8382],\n        children: [\n            {\n                value: [1212, 4943, 5453],\n                id: &#39;someid-1&#39;,\n                name: &#39;description of this node&#39;,\n                children: [...]\n            },\n            {\n                value: [4545, 192, 439],\n                id: &#39;someid-2&#39;,\n                name: &#39;description of this node&#39;,\n                children: [...]\n            },\n            ...\n        ]\n    },\n    {\n        value: [23, 59, 12],\n        children: [...]\n    },\n    ...\n]\n</code></pre>\n<p><code class=\"codespan\">treemap</code> will map the first dimension (the first item of the array) to &quot;area&quot;. If we want to express more information, we could map another dimension (specified by <a href=\"#series-treemap.viusalDimension\">series-treemap.visualDimension</a>) to another visual types, such as <code class=\"codespan\">colorSaturation</code> and so on. See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=treemap-obama&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> and select the legend &#39;Growth&#39;.</p>\n<p><strong>How to avoid confusion by setting border/gap of node</strong></p>\n<p>If all of the border/gaps are set with the same color, confusion might occur when rectangulars in different levels display at the same time.</p>\n<p>See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/treemap-borderColor&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>. Notice that the child rectangles in the red area are in the deeper level than rectangles that are saparated by white gap. So in the red area, basically we set gap color with red, and use <code class=\"codespan\">borderColorSaturation</code> to lift the saturation.</p>\n<p><strong>Explanation about borderWidth, gapWidth, borderColor</strong></p>\n<p><img width=\"500\" height=\"auto\" src=\"documents/asset/img/treemap-border-gap.png\"></p>\n","items":{"type":"Object","properties":{"visualDimension":{"type":["number"],"description":"<p><code class=\"codespan\">treemap</code> is able to map any dimensions of data to visual.</p>\n<p>The value of <a href=\"#series-treemap.data\">series-treemap.data</a> can be an array. And each item of the array represents a &quot;dimension&quot;. <code class=\"codespan\">visualDimension</code> specifies the dimension on which visual mapping will be performed.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">visualDimension</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","default":0},"visualMin":{"type":["number"],"description":"\n\n<p>The minimal value of current level. Auto-statistics by default.</p>\n<p>When <a href=\"#series-treemap.levels.colorMappingBy\">colorMappingBy</a> is set to <code class=\"codespan\">&#39;value&#39;</code>, you are able to specify extent manually for visual mapping by specifying <code class=\"codespan\">visualMin</code> or <code class=\"codespan\">visualMax</code>.</p>\n","uiControl":{"type":"number","default":"0"},"default":null},"visualMax":{"type":["number"],"description":"\n\n<p>The maximal value of current level. Auto-statistics by default.</p>\n<p>When <a href=\"#series-treemap.levels.colorMappingBy\">colorMappingBy</a> is set to <code class=\"codespan\">&#39;value&#39;</code>, you are able to specify extent manually for visual mapping by specifying <code class=\"codespan\">visualMin</code> or <code class=\"codespan\">visualMax</code>.</p>\n","uiControl":{"type":"number","default":"100"},"default":null},"color":{"type":["Array"],"description":"<p>A color list for a level. Each node in the level will obtain a color from the color list (the rule see <a href=\"#series-treemap.levels.colorMappingBy\">colorMappingBy</a>). It is empty by default, which means the global color list will be used.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">color</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n"},"colorAlpha":{"type":["Array"],"description":"<p>It indicates the range of tranparent rate (color alpha) for nodes in a level</p>\n<p>.\nThe range of values is 0 ~ 1.</p>\n<p>For example, <code class=\"codespan\">colorAlpha</code> can be <code class=\"codespan\">[0.3, 1]</code>.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">colorAlpha</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","default":null},"colorSaturation":{"type":["number"],"description":"<p>It indicates the range of saturation (color alpha) for nodes in a level.</p>\n<p>The range of values is 0 ~ 1.</p>\n<p>For example, <code class=\"codespan\">colorSaturation</code> can be <code class=\"codespan\">[0.3, 1]</code>.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">colorSaturation</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","default":null},"colorMappingBy":{"type":["string"],"description":"\n\n<p>Specify the rule according to which each node obtain color from <a href=\"#series-treemap.levels.color\">color list</a>. Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;value&#39;</code>:</li>\n</ul>\n<p>Map <a href=\"#series-treemap.data.value\">series-treemap.data.value</a> to color.</p>\n<p>In this way, the color of each node indicate its value.</p>\n<p><a href=\"#series-treemap.levels.visualDimension\">visualDimension</a> can be used to specify which dimension of <a href=\"#series-treemap.data\">data</a> is used to perform visual mapping.</p>\n<ul>\n<li><code class=\"codespan\">&#39;index&#39;</code>:</li>\n</ul>\n<p>Map the <code class=\"codespan\">index</code> (ordinal number) of nodes to color. Namely, in a level, the first node is mapped to the first color of <a href=\"#series-treemap.levels.color\">color list</a>, and the second node gets the second color.</p>\n<p>In this way, adjacent nodes are distinguished by color.</p>\n<ul>\n<li><code class=\"codespan\">&#39;id&#39;</code>:</li>\n</ul>\n<p>Map <a href=\"#series-treemap.data.id\">series-treemap.data.id</a> to color.</p>\n<p>Since <code class=\"codespan\">id</code> is used to identify node, if user call <code class=\"codespan\">setOption</code> to modify the tree, each node will remain the original color before and after <code class=\"codespan\">setOption</code> called. See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=treemap-obama&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">colorMappingBy</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","uiControl":{"type":"enum","options":"index,value,id"},"default":"'index'"},"visibleMin":{"type":["number"],"description":"\n\n<p>A node will not be shown when its area size is smaller than this value (unit: px square).</p>\n<p>In this way, tiny nodes will be hidden, otherwise they will huddle together. When user zoom the treemap, the area size will increase and the rectangle will be shown if the area size is larger than this threshold.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">visibleMin</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","uiControl":{"type":"number","default":"10","min":"0"},"default":10},"childrenVisibleMin":{"type":["number"],"description":"\n\n<p>Children will not be shown when area size of a node is smaller than this value (unit: px square).</p>\n<p>This can hide the details of nodes when the rectangular area is not large enough. When users zoom nodes, the child node would show if the area is larger than this threshold.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">childrenVisibleMin</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","uiControl":{"type":"number","default":"10","min":"0","step":"0.5"},"default":null},"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> decribes the style of the label in each node.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">label</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"upperLabel":{"type":["Object"],"description":"<p><code class=\"codespan\">upperLabel</code> is used to specify whether show label when the node has children. When <a href=\"#series-treemap.upperLabel.show\">upperLabel.show</a> is set as <code class=\"codespan\">true</code>, the feature that &quot;show parent label&quot; is enabled.</p>\n<p>The same as <a href=\"#series-treemap.label\">series-treemap.label</a>, the option <code class=\"codespan\">upperLabel</code> can be placed at the root of <a href=\"#series-treemap\">series-treemap</a> directly, or in <a href=\"#series-treemap.level\">series-treemap.level</a>, or in each item of <a href=\"#series-treemap.data\">series-treemap.data</a>.</p>\n<p>Specifically, <a href=\"#series-treemap.label\">series-treemap.label</a> specifies the style when a node is a leaf, while <code class=\"codespan\">upperLabel</code> specifies the style when a node has children, in which case the label is displayed in the inner top of the node.</p>\n<p>See:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=treemap-show-parent&edit=1&reset=1\" width=\"700\" height=\"500\"></iframe>\n\n\n\n\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">label</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of label area.</p>\n","uiControl":{"type":"number","default":"20","min":"0","step":"0.5"},"default":20},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">itemStyle</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of a node. It use global palette <a href=\"#color\">option.color</a> by default.</p>\n","uiControl":{"type":"color"},"default":null},"colorAlpha":{"type":["number"],"description":"\n\n<p>The tranparent rate of a node, the range is between 0 ~ 1.</p>\n","uiControl":{"type":"number","step":"0.01","min":"0","max":"1","default":"1"},"default":null},"colorSaturation":{"type":["number"],"description":"\n\n<p>The color saturation of a node. The range is between 0 ~ 1.</p>\n","uiControl":{"type":"number","step":"0.01","min":"0","max":"1","default":"0.5"},"default":null},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>Border radius.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB","clean":"true"},"default":0},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of a node. There is no border when it is set as <code class=\"codespan\">0</code>.</p>\n<p>Tip, gaps between child nodes are specified by <a href=\"#series-treemap.levels.gapWidth\">gapWidth</a></p>\n","uiControl":{"type":"number","step":"0.5","min":"0"},"default":0},"gapWidth":{"type":["number"],"description":"\n\n<p>Gaps between child nodes.</p>\n","uiControl":{"type":"number","step":"0.5","min":"0"},"default":0},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color and gap color of a node.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'#fff',"},"borderColorSaturation":{"type":["Color"],"description":"\n\n<p>The color saturation of a border or gap. The value range is between 0 ~ 1.</p>\n<p>Tips:</p>\n<p>When <code class=\"codespan\">borderColorSaturation</code> is set, the <code class=\"codespan\">borderColor</code> is disabled, and, instead, the final border color is calculated based on the color of this node (this color could be sepcified explicitly or inherited from its parent node) and mixing with <code class=\"codespan\">borderColorSaturation</code>.</p>\n<p>In this way, a effect can be implemented: different sections have different hue of gap color repectively, which makes users easy to distinguish both sections and levels.</p>\n<p><strong>How to avoid confusion by setting border/gap of node</strong></p>\n<p>If all of the border/gaps are set with the same color, confusion might occur when rectangulars in different levels display at the same time.</p>\n<p>See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/treemap-borderColor&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>. Notice that the child rectangles in the red area are in the deeper level than rectangles that are saparated by white gap. So in the red area, basically we set gap color with red, and use <code class=\"codespan\">borderColorSaturation</code> to lift the saturation.</p>\n","uiControl":{"type":"number","step":"0.01","min":"0","max":"1","default":"0.5"},"default":null},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"upperLabel":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of a node. It use global palette <a href=\"#color\">option.color</a> by default.</p>\n","uiControl":{"type":"color"},"default":null}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"upperLabel":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of a node. It use global palette <a href=\"#color\">option.color</a> by default.</p>\n","uiControl":{"type":"color"},"default":null}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"upperLabel":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of a node. It use global palette <a href=\"#color\">option.color</a> by default.</p>\n","uiControl":{"type":"color"},"default":null}}}}}}}},"data":{"type":["Array"],"description":"<p>the the data format of <a href=\"#series-treemap.data\">series-treemap.data</a> is a forest. For example:</p>\n<pre><code class=\"lang-javascript\">[ // Tips, the top level is an array.\n    {\n        value: 1212,\n        children: [\n            {\n                value: 2323,    // The value of this node, indicating the area size.\n                                // it could also be an array, such as [2323, 43, 55], in which the first item of array indicates the area size.\n                                // The other items of the array can be used for extra visual mapping. See details in series-treemp.levels.\n                id: &#39;someid-1&#39;, // id is not mandatory.\n                                // But if using API, id is used to locate node.\n                name: &#39;description of this node&#39;, // show the description text in rectangle.\n                children: [...],\n                label: {        // The label config of this node (if necessary).\n                    ...         // see series-treemap.label.\n                },\n                itemStyle: {    // the itemStyle of this node (if necessary).\n                    ...         // the see series-treemap.itemStyle.\n                }\n            },\n            {\n                value: 4545,\n                id: &#39;someid-2&#39;,\n                name: &#39;description of this node&#39;,\n                children: [\n                    {\n                        value: 5656,\n                        id: &#39;someid-3&#39;,\n                        name: &#39;description of this node&#39;,\n                        children: [...]\n                    },\n                    ...\n                ]\n            }\n        ]\n    },\n    {\n        value: [23, 59, 12]\n        // if there is no children, here could be nothing.\n    },\n    ...\n]\n</code></pre>\n","items":{"type":"Object","properties":{"value":{"type":["number","Array"],"description":"<p>The value of this node, indicating the area size.</p>\n<p>It could also be an array, such as [2323, 43, 55], in which the first item of array indicates the area size.</p>\n<p>The other items of the array can be used for extra visual mapping. See details in series-treemp.levels.</p>\n"},"id":{"type":["string"],"description":"<p><code class=\"codespan\">id</code> is not mandatory.\nBut if using API, id is used to locate node.</p>\n"},"name":{"type":["string"],"description":"<p>Show the description text in rectangle.</p>\n"},"visualDimension":{"type":["number"],"description":"<p><code class=\"codespan\">treemap</code> is able to map any dimensions of data to visual.</p>\n<p>The value of <a href=\"#series-treemap.data\">series-treemap.data</a> can be an array. And each item of the array represents a &quot;dimension&quot;. <code class=\"codespan\">visualDimension</code> specifies the dimension on which visual mapping will be performed.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">visualDimension</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","default":0},"visualMin":{"type":["number"],"description":"\n\n<p>The minimal value of current level. Auto-statistics by default.</p>\n<p>When <a href=\"#series-treemap.levels.colorMappingBy\">colorMappingBy</a> is set to <code class=\"codespan\">&#39;value&#39;</code>, you are able to specify extent manually for visual mapping by specifying <code class=\"codespan\">visualMin</code> or <code class=\"codespan\">visualMax</code>.</p>\n","uiControl":{"type":"number","default":"0"},"default":null},"visualMax":{"type":["number"],"description":"\n\n<p>The maximal value of current level. Auto-statistics by default.</p>\n<p>When <a href=\"#series-treemap.levels.colorMappingBy\">colorMappingBy</a> is set to <code class=\"codespan\">&#39;value&#39;</code>, you are able to specify extent manually for visual mapping by specifying <code class=\"codespan\">visualMin</code> or <code class=\"codespan\">visualMax</code>.</p>\n","uiControl":{"type":"number","default":"100"},"default":null},"color":{"type":["Array"],"description":"<p>A color list for a level. Each node in the level will obtain a color from the color list (the rule see <a href=\"#series-treemap.levels.colorMappingBy\">colorMappingBy</a>). It is empty by default, which means the global color list will be used.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">color</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n"},"colorAlpha":{"type":["Array"],"description":"<p>It indicates the range of tranparent rate (color alpha) for nodes in a level</p>\n<p>.\nThe range of values is 0 ~ 1.</p>\n<p>For example, <code class=\"codespan\">colorAlpha</code> can be <code class=\"codespan\">[0.3, 1]</code>.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">colorAlpha</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","default":null},"colorSaturation":{"type":["number"],"description":"<p>It indicates the range of saturation (color alpha) for nodes in a level.</p>\n<p>The range of values is 0 ~ 1.</p>\n<p>For example, <code class=\"codespan\">colorSaturation</code> can be <code class=\"codespan\">[0.3, 1]</code>.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">colorSaturation</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","default":null},"colorMappingBy":{"type":["string"],"description":"\n\n<p>Specify the rule according to which each node obtain color from <a href=\"#series-treemap.levels.color\">color list</a>. Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;value&#39;</code>:</li>\n</ul>\n<p>Map <a href=\"#series-treemap.data.value\">series-treemap.data.value</a> to color.</p>\n<p>In this way, the color of each node indicate its value.</p>\n<p><a href=\"#series-treemap.levels.visualDimension\">visualDimension</a> can be used to specify which dimension of <a href=\"#series-treemap.data\">data</a> is used to perform visual mapping.</p>\n<ul>\n<li><code class=\"codespan\">&#39;index&#39;</code>:</li>\n</ul>\n<p>Map the <code class=\"codespan\">index</code> (ordinal number) of nodes to color. Namely, in a level, the first node is mapped to the first color of <a href=\"#series-treemap.levels.color\">color list</a>, and the second node gets the second color.</p>\n<p>In this way, adjacent nodes are distinguished by color.</p>\n<ul>\n<li><code class=\"codespan\">&#39;id&#39;</code>:</li>\n</ul>\n<p>Map <a href=\"#series-treemap.data.id\">series-treemap.data.id</a> to color.</p>\n<p>Since <code class=\"codespan\">id</code> is used to identify node, if user call <code class=\"codespan\">setOption</code> to modify the tree, each node will remain the original color before and after <code class=\"codespan\">setOption</code> called. See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=treemap-obama&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">colorMappingBy</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","uiControl":{"type":"enum","options":"index,value,id"},"default":"'index'"},"visibleMin":{"type":["number"],"description":"\n\n<p>A node will not be shown when its area size is smaller than this value (unit: px square).</p>\n<p>In this way, tiny nodes will be hidden, otherwise they will huddle together. When user zoom the treemap, the area size will increase and the rectangle will be shown if the area size is larger than this threshold.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">visibleMin</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","uiControl":{"type":"number","default":"10","min":"0"},"default":10},"childrenVisibleMin":{"type":["number"],"description":"\n\n<p>Children will not be shown when area size of a node is smaller than this value (unit: px square).</p>\n<p>This can hide the details of nodes when the rectangular area is not large enough. When users zoom nodes, the child node would show if the area is larger than this threshold.</p>\n<p>About visual encoding, see details in <a href=\"#series-treemap.levels\">series-treemap.levels</a>.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">childrenVisibleMin</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","uiControl":{"type":"number","default":"10","min":"0","step":"0.5"},"default":null},"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> decribes the style of the label in each node.</p>\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">label</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"upperLabel":{"type":["Object"],"description":"<p><code class=\"codespan\">upperLabel</code> is used to specify whether show label when the node has children. When <a href=\"#series-treemap.upperLabel.show\">upperLabel.show</a> is set as <code class=\"codespan\">true</code>, the feature that &quot;show parent label&quot; is enabled.</p>\n<p>The same as <a href=\"#series-treemap.label\">series-treemap.label</a>, the option <code class=\"codespan\">upperLabel</code> can be placed at the root of <a href=\"#series-treemap\">series-treemap</a> directly, or in <a href=\"#series-treemap.level\">series-treemap.level</a>, or in each item of <a href=\"#series-treemap.data\">series-treemap.data</a>.</p>\n<p>Specifically, <a href=\"#series-treemap.label\">series-treemap.label</a> specifies the style when a node is a leaf, while <code class=\"codespan\">upperLabel</code> specifies the style when a node has children, in which case the label is displayed in the inner top of the node.</p>\n<p>See:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=treemap-show-parent&edit=1&reset=1\" width=\"700\" height=\"500\"></iframe>\n\n\n\n\n<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">label</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of label area.</p>\n","uiControl":{"type":"number","default":"20","min":"0","step":"0.5"},"default":20},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<blockquote>\n<p>Tps: In treemap, <code class=\"codespan\">itemStyle</code> attribute could appear in more than one places:</p>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in <a href=\"#series-treemap\">sereis-treemap</a>, indicating the unified setting of the series.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each array element of  <a href=\"#series-treemap.levels\">series-treemap.levels</a>, indicating the unified setting of each level of the tree.</li>\n</ul>\n</blockquote>\n<blockquote>\n<ul>\n<li>It could appear in each node of <a href=\"#series-treemap.data\">series-treemap.data</a>, indicating the particular setting of each node.</li>\n</ul>\n</blockquote>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of a node. It use global palette <a href=\"#color\">option.color</a> by default.</p>\n","uiControl":{"type":"color"},"default":null},"colorAlpha":{"type":["number"],"description":"\n\n<p>The tranparent rate of a node, the range is between 0 ~ 1.</p>\n","uiControl":{"type":"number","step":"0.01","min":"0","max":"1","default":"1"},"default":null},"colorSaturation":{"type":["number"],"description":"\n\n<p>The color saturation of a node. The range is between 0 ~ 1.</p>\n","uiControl":{"type":"number","step":"0.01","min":"0","max":"1","default":"0.5"},"default":null},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>Border radius.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB","clean":"true"},"default":0},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of a node. There is no border when it is set as <code class=\"codespan\">0</code>.</p>\n<p>Tip, gaps between child nodes are specified by <a href=\"#series-treemap.levels.gapWidth\">gapWidth</a></p>\n","uiControl":{"type":"number","step":"0.5","min":"0"},"default":0},"gapWidth":{"type":["number"],"description":"\n\n<p>Gaps between child nodes.</p>\n","uiControl":{"type":"number","step":"0.5","min":"0"},"default":0},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color and gap color of a node.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'#fff',"},"borderColorSaturation":{"type":["Color"],"description":"\n\n<p>The color saturation of a border or gap. The value range is between 0 ~ 1.</p>\n<p>Tips:</p>\n<p>When <code class=\"codespan\">borderColorSaturation</code> is set, the <code class=\"codespan\">borderColor</code> is disabled, and, instead, the final border color is calculated based on the color of this node (this color could be sepcified explicitly or inherited from its parent node) and mixing with <code class=\"codespan\">borderColorSaturation</code>.</p>\n<p>In this way, a effect can be implemented: different sections have different hue of gap color repectively, which makes users easy to distinguish both sections and levels.</p>\n<p><strong>How to avoid confusion by setting border/gap of node</strong></p>\n<p>If all of the border/gaps are set with the same color, confusion might occur when rectangulars in different levels display at the same time.</p>\n<p>See the <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/treemap-borderColor&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a>. Notice that the child rectangles in the red area are in the deeper level than rectangles that are saparated by white gap. So in the red area, basically we set gap color with red, and use <code class=\"codespan\">borderColorSaturation</code> to lift the saturation.</p>\n","uiControl":{"type":"number","step":"0.01","min":"0","max":"1","default":"0.5"},"default":null},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"upperLabel":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of a node. It use global palette <a href=\"#color\">option.color</a> by default.</p>\n","uiControl":{"type":"color"},"default":null}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"upperLabel":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of a node. It use global palette <a href=\"#color\">option.color</a> by default.</p>\n","uiControl":{"type":"color"},"default":null}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"upperLabel":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>The color of a node. It use global palette <a href=\"#color\">option.color</a> by default.</p>\n","uiControl":{"type":"color"},"default":null}}}}},"link":{"type":["string"],"description":"<p>Enable hyperlink jump when clicking on node. It is avaliable when <a href=\"#series-treemap.nodeClick\">series-treemap.nodeClick</a> is <code class=\"codespan\">&#39;link&#39;</code>.</p>\n<p>See <a href=\"#series-treemap.data.target\">series-treemap.data.target</a>.</p>\n"},"target":{"type":["string"],"description":"<p>The same meaning as <code class=\"codespan\">target</code> in <code class=\"codespan\">html</code> <code class=\"codespan\">&lt;a&gt;</code> label, See <a href=\"#series-treemap.data.link\">series-treemap.data.link</a>. Option values are: <code class=\"codespan\">&#39;blank&#39;</code> or <code class=\"codespan\">&#39;self&#39;</code>.</p>\n","default":"'blank'"},"children":{"type":["Array"],"description":"<p>child nodes, recursive definition, configurations are the same as <a href=\"#series-treemap.data\">series-treemap.data</a>.</p>\n"},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series data.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}}},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1500","step":"20","clean":"true"},"default":1500},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"quinticInOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p><a href=\"https://en.wikipedia.org/wiki/Pie_chart#Ring_chart_/_Sunburst_chart_/_Multilevel_pie_chart\" target=\"_blank\">Sunburst Chart</a> is composed of multiple pie charts. From the view of data structure, inner rings are the parent nodes of outer rings. Therefore, it can show the partial-overall relationship as <a href=\"#series-pie\">Pie</a> charts, and also level relation as <a href=\"#series-treemap\">Treemap</a> charts.</p>\n<p><strong>For example:</strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=sunburst-monochrome&edit=1&reset=1\" width=\"700\" height=\"500\"></iframe>\n\n\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=sunburst-drink&edit=1&reset=1\" width=\"700\" height=\"700\"></iframe>\n\n\n<p><strong>Data mining</strong></p>\n<p>Sunburst charts support data mining by default. That means, when a user clicks a sector, it will be used as root node, and there will be a circle in the center for return to parent node. If data mining is not needed, it can be disabled by <a href=\"#series-treemap.nodeClick\">series-sunburst.nodeClick</a>.</p>\n","properties":{"type":{"type":["string"],"description":"","default":"'sunburst'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"center":{"type":["Array"],"description":"\n\n<p>Center position of Sunburst chart, the first of which is the horizontal position, and the second is the vertical position.</p>\n<p>Percentage is supported. When set in percentage, the item is relative to the container width, and the second item to the height.</p>\n<p><strong>Example: </strong></p>\n<pre><code>// Set to absolute pixel values\ncenter: [400, 300]\n// Set to relative percent\ncenter: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>","uiControl":{"type":"percentvector","dims":"x,y"},"default":"['50%', '50%']"},"radius":{"type":["number","string","Array"],"description":"\n\n<p>Radius of Sunburst chart. Value can be:</p>\n<ul>\n<li><code class=\"codespan\">number</code>: Specify outside radius directly.</li>\n<li><code class=\"codespan\">string</code>: For example, <code class=\"codespan\">&#39;20%&#39;</code>, means that the outside radius is 20% of the viewport size (the little one between width and height of the chart container).</li>\n</ul>\n<ul>\n<li><code class=\"codespan\">Array.&lt;number|string&gt;</code>: The first item specifies the inside radius, and the second item specifies the outside radius. Each item follows the definitions above.</li>\n</ul>\n","uiControl":{"type":"percentvector","dims":"inner,outer","default":"0%, 75%"},"default":"[0, '75%']"},"data":{"type":["Array"],"description":"<p>The data structure of <a href=\"#series-sunburst.data\">series-sunburst.data</a> is like tree. For example:</p>\n<pre><code class=\"lang-js\">[{\n    name: &#39;parent1&#39;,\n    value: 10,          // value of parent node can be left unset, and sum of\n                        // children values will be used in this case.\n                        // If is set, and is larger than sum of children nodes,\n                        // the reset can be used for other parts in parent.\n    children: [{\n        value: 5,\n        name: &#39;child1&#39;,\n        children: [{\n            value: 2,\n            name: &#39;grandchild1&#39;,\n            itemStyle: {\n                // every data can have its own itemStyle,\n                // which will overwrites series.itemStyle and level.itemStyle\n            },\n            label: {\n                // label style, the same to above\n            }\n        }]\n    }, {\n        value: 3,\n        name: &#39;child2&#39;\n    }],\n    itemStyle: {\n        // itemStyle of parent1, which will not be inherited for children\n    },\n    label: {\n        // label of parent1, which will not be inherited for children\n    }\n}, {\n    name: &#39;parent2&#39;,\n    value: 4\n}]\n</code></pre>\n","items":{"type":"Object","properties":{"value":{"type":["number"],"description":"<p>Value for each item. If contains children, value can be left unset, and sum of children values will be used in this case.</p>\n"},"name":{"type":["string"],"description":"<p>Name displayed in each sector.</p>\n"},"link":{"type":["string"],"description":"<p>Link address that redirects to when this sector is clicked. Only useful when <a href=\"#series-treemap.nodeClick\">series-sunburst.nodeClick</a> is set to be <code class=\"codespan\">&#39;link&#39;</code>.</p>\n<p>See <a href=\"#series-sunburst.data.target\">series-sunburst.data.target</a>.</p>\n"},"target":{"type":["string"],"description":"<p>Like <code class=\"codespan\">target</code> attribute of HTML <code class=\"codespan\">&lt;a&gt;</code>, which can either be <code class=\"codespan\">&#39;blank&#39;</code> or <code class=\"codespan\">&#39;self&#39;</code>. See <a href=\"#series-sunburst.data.link\">series-sunburst.data.link</a>.</p>\n","default":"'blank'"},"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> 描述了每个扇形块中，文本标签的样式。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.label\">series.data.label</a> &gt; <a href=\"#series-sunburst.levels.label\">series.levels.label</a> &gt; <a href=\"#series-sunburst.label\">series.label</a>。</strong></p>\n<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"rotate":{"type":["string","number"],"description":"\n\n\n<p>同 <a href=\"#sunburst.label.rotate\">label.rotate</a></p>\n","uiControl":{"type":"enum","options":"radial,tangential","default":"radial"},"default":"'radial'"},"align":{"type":["string"],"description":"\n\n<p>Align of text, which can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>. Note that <code class=\"codespan\">&#39;left&#39;</code> stands for inner side, and <code class=\"codespan\">&#39;right&#39;</code> stands for outer side.</p>\n<p>Same to <a href=\"#sunburst.label.align\">label.align</a></p>\n","uiControl":{"type":"enum","options":"left,center,right","default":"center"},"default":"'center'"},"minAngle":{"type":["number"],"description":"\n\n<p>If angle of data piece is smaller than this value (in degrees), then text is not displayed. This is used for hiding text for small piece of data.</p>\n","uiControl":{"type":"angle","min":"0","step":"1","max":"360"},"default":null},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>旭日图扇形块的样式。</p>\n<p>可以在 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 定义所有扇形块的样式，也可以在 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> 定义每一层扇形块的样式，还可以在 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> 定义每个扇形块单独的样式，这三者的优先级从低到高。也就是说，如果定义了 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a>，将会覆盖 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 和 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a>。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> &gt; <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> &gt; <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a>。</strong></p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'white'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"},"default":1},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"},"emphasis":{"type":["*"],"description":"<p>Emphasis state.</p>\n","properties":{"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> 描述了每个扇形块中，文本标签的样式。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.label\">series.data.label</a> &gt; <a href=\"#series-sunburst.levels.label\">series.levels.label</a> &gt; <a href=\"#series-sunburst.label\">series.label</a>。</strong></p>\n<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"rotate":{"type":["string","number"],"description":"\n\n\n<p>同 <a href=\"#sunburst.label.rotate\">label.rotate</a></p>\n","uiControl":{"type":"enum","options":"radial,tangential","default":"radial"},"default":"'radial'"},"align":{"type":["string"],"description":"\n\n<p>Align of text, which can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>. Note that <code class=\"codespan\">&#39;left&#39;</code> stands for inner side, and <code class=\"codespan\">&#39;right&#39;</code> stands for outer side.</p>\n<p>Same to <a href=\"#sunburst.label.align\">label.align</a></p>\n","uiControl":{"type":"enum","options":"left,center,right","default":"center"},"default":"'center'"},"minAngle":{"type":["number"],"description":"\n\n<p>If angle of data piece is smaller than this value (in degrees), then text is not displayed. This is used for hiding text for small piece of data.</p>\n","uiControl":{"type":"angle","min":"0","step":"1","max":"360"},"default":null},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>旭日图扇形块的样式。</p>\n<p>可以在 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 定义所有扇形块的样式，也可以在 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> 定义每一层扇形块的样式，还可以在 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> 定义每个扇形块单独的样式，这三者的优先级从低到高。也就是说，如果定义了 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a>，将会覆盖 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 和 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a>。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> &gt; <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> &gt; <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a>。</strong></p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'white'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"},"default":1}}}}},"blur":{"type":["*"],"description":"<p>Blur state.</p>\n","properties":{"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> 描述了每个扇形块中，文本标签的样式。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.label\">series.data.label</a> &gt; <a href=\"#series-sunburst.levels.label\">series.levels.label</a> &gt; <a href=\"#series-sunburst.label\">series.label</a>。</strong></p>\n<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"rotate":{"type":["string","number"],"description":"\n\n\n<p>同 <a href=\"#sunburst.label.rotate\">label.rotate</a></p>\n","uiControl":{"type":"enum","options":"radial,tangential","default":"radial"},"default":"'radial'"},"align":{"type":["string"],"description":"\n\n<p>Align of text, which can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>. Note that <code class=\"codespan\">&#39;left&#39;</code> stands for inner side, and <code class=\"codespan\">&#39;right&#39;</code> stands for outer side.</p>\n<p>Same to <a href=\"#sunburst.label.align\">label.align</a></p>\n","uiControl":{"type":"enum","options":"left,center,right","default":"center"},"default":"'center'"},"minAngle":{"type":["number"],"description":"\n\n<p>If angle of data piece is smaller than this value (in degrees), then text is not displayed. This is used for hiding text for small piece of data.</p>\n","uiControl":{"type":"angle","min":"0","step":"1","max":"360"},"default":null},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>旭日图扇形块的样式。</p>\n<p>可以在 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 定义所有扇形块的样式，也可以在 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> 定义每一层扇形块的样式，还可以在 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> 定义每个扇形块单独的样式，这三者的优先级从低到高。也就是说，如果定义了 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a>，将会覆盖 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 和 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a>。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> &gt; <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> &gt; <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a>。</strong></p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'white'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"},"default":1}}}}},"select":{"type":["*"],"description":"<p>Select state.</p>\n","properties":{"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> 描述了每个扇形块中，文本标签的样式。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.label\">series.data.label</a> &gt; <a href=\"#series-sunburst.levels.label\">series.levels.label</a> &gt; <a href=\"#series-sunburst.label\">series.label</a>。</strong></p>\n<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"rotate":{"type":["string","number"],"description":"\n\n\n<p>同 <a href=\"#sunburst.label.rotate\">label.rotate</a></p>\n","uiControl":{"type":"enum","options":"radial,tangential","default":"radial"},"default":"'radial'"},"align":{"type":["string"],"description":"\n\n<p>Align of text, which can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>. Note that <code class=\"codespan\">&#39;left&#39;</code> stands for inner side, and <code class=\"codespan\">&#39;right&#39;</code> stands for outer side.</p>\n<p>Same to <a href=\"#sunburst.label.align\">label.align</a></p>\n","uiControl":{"type":"enum","options":"left,center,right","default":"center"},"default":"'center'"},"minAngle":{"type":["number"],"description":"\n\n<p>If angle of data piece is smaller than this value (in degrees), then text is not displayed. This is used for hiding text for small piece of data.</p>\n","uiControl":{"type":"angle","min":"0","step":"1","max":"360"},"default":null},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>旭日图扇形块的样式。</p>\n<p>可以在 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 定义所有扇形块的样式，也可以在 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> 定义每一层扇形块的样式，还可以在 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> 定义每个扇形块单独的样式，这三者的优先级从低到高。也就是说，如果定义了 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a>，将会覆盖 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 和 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a>。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> &gt; <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> &gt; <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a>。</strong></p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'white'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"},"default":1}}}}},"children":{"type":["Array"],"description":"<p>子节点，递归定义，格式同 <a href=\"#series-sunburst.data\">series-sunburst.data</a>。</p>\n"}}},"nodeClick":{"type":["boolean","string"],"description":"\n\n<p>The action of clicking a sector, which can be:</p>\n<ul>\n<li><code class=\"codespan\">false</code>: nothing happens.</li>\n<li><code class=\"codespan\">&#39;rootToNode&#39;</code>: use the clicked sector as root.</li>\n<li><code class=\"codespan\">&#39;link&#39;</code>：if <a href=\"#series-sunburst.data.link\">link</a> is set, the page will redirect to it.</li>\n</ul>\n","uiControl":{"type":"enum","default":"rootToNode","options":"rootToNode,link"},"default":"'rootToNode'"},"sort":{"type":["string","Function"],"description":"\n\n<p>Sorting method that sectors use based on <a href=\"#series-sunburst.data.value\"><code class=\"codespan\">value</code></a>, which is the sum of children when not set. The default value <code class=\"codespan\">&#39;desc&#39;</code> states for descending order, while it can also be set to be <code class=\"codespan\">&#39;asc&#39;</code> for ascending order, or <code class=\"codespan\">null</code> for not sorting, or callback function like:</p>\n<pre><code class=\"lang-js\">function(nodeA, nodeB) {\n    return nodeA.getValue() - nodeB.getValue();\n}\n</code></pre>\n","uiControl":{"type":"enum","default":"desc","options":"desc,asc"},"default":"'desc'"},"renderLabelForZeroData":{"type":["boolean"],"description":"\n\n<p>If there is no <code class=\"codespan\">name</code>, whether need to render it.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> 描述了每个扇形块中，文本标签的样式。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.label\">series.data.label</a> &gt; <a href=\"#series-sunburst.levels.label\">series.levels.label</a> &gt; <a href=\"#series-sunburst.label\">series.label</a>。</strong></p>\n<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"rotate":{"type":["string","number"],"description":"\n\n\n<p>If it is <code class=\"codespan\">number</code> type, then is stands for rotation, from -90 degrees to 90 degrees, and positive values stand for counterclockwise.</p>\n<p>Besides, it can be string <code class=\"codespan\">&#39;radial&#39;</code>, standing for radial rotation; or <code class=\"codespan\">&#39;tangential&#39;</code>, standing for tangential rotation.</p>\n<p>By default, it is <code class=\"codespan\">&#39;radial&#39;</code>. If no rotation is wanted, it can be set to <code class=\"codespan\">0</code>.</p>\n<p>The following example shows different <code class=\"codespan\">rotate</code> settings:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=sunburst-label-rotate&edit=1&reset=1\" width=\"700\" height=\"400\"></iframe>\n\n\n<p>Same to <a href=\"#sunburst.label.rotate\">label.rotate</a></p>\n","uiControl":{"type":"enum","options":"radial,tangential","default":"radial"},"default":"'radial'"},"align":{"type":["string"],"description":"\n\n<p>Align of text, which can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>. Note that <code class=\"codespan\">&#39;left&#39;</code> stands for inner side, and <code class=\"codespan\">&#39;right&#39;</code> stands for outer side.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/sunburst-label-align&edit=1&reset=1\" width=\"700\" height=\"400\"></iframe>\n\n\n","uiControl":{"type":"enum","options":"left,center,right","default":"center"},"default":"'center'"},"minAngle":{"type":["number"],"description":"\n\n<p>If angle of data piece is smaller than this value (in degrees), then text is not displayed. This is used for hiding text for small piece of data.</p>\n","uiControl":{"type":"angle","min":"0","step":"1","max":"360"},"default":null},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>旭日图扇形块的样式。</p>\n<p>可以在 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 定义所有扇形块的样式，也可以在 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> 定义每一层扇形块的样式，还可以在 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> 定义每个扇形块单独的样式，这三者的优先级从低到高。也就是说，如果定义了 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a>，将会覆盖 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 和 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a>。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> &gt; <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> &gt; <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a>。</strong></p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'white'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"},"default":1}}},"emphasis":{"type":["*"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<ul>\n<li><code class=\"codespan\">&#39;ancestor&#39;</code> Focus on all ancestor nodes.</li>\n<li><code class=\"codespan\">&#39;descendant&#39;</code> Focus on all descendants nodes.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> 描述了每个扇形块中，文本标签的样式。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.label\">series.data.label</a> &gt; <a href=\"#series-sunburst.levels.label\">series.levels.label</a> &gt; <a href=\"#series-sunburst.label\">series.label</a>。</strong></p>\n<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"rotate":{"type":["string","number"],"description":"\n\n\n<p>同 <a href=\"#sunburst.label.rotate\">label.rotate</a></p>\n","uiControl":{"type":"enum","options":"radial,tangential","default":"radial"},"default":"'radial'"},"align":{"type":["string"],"description":"\n\n<p>Align of text, which can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>. Note that <code class=\"codespan\">&#39;left&#39;</code> stands for inner side, and <code class=\"codespan\">&#39;right&#39;</code> stands for outer side.</p>\n<p>Same to <a href=\"#sunburst.label.align\">label.align</a></p>\n","uiControl":{"type":"enum","options":"left,center,right","default":"center"},"default":"'center'"},"minAngle":{"type":["number"],"description":"\n\n<p>If angle of data piece is smaller than this value (in degrees), then text is not displayed. This is used for hiding text for small piece of data.</p>\n","uiControl":{"type":"angle","min":"0","step":"1","max":"360"},"default":null},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>旭日图扇形块的样式。</p>\n<p>可以在 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 定义所有扇形块的样式，也可以在 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> 定义每一层扇形块的样式，还可以在 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> 定义每个扇形块单独的样式，这三者的优先级从低到高。也就是说，如果定义了 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a>，将会覆盖 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 和 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a>。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> &gt; <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> &gt; <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a>。</strong></p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'white'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"},"default":1},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}}}},"blur":{"type":["*"],"description":"<p>Configurations of blur state. Available when <a href=\"#series-sunburst.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> 描述了每个扇形块中，文本标签的样式。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.label\">series.data.label</a> &gt; <a href=\"#series-sunburst.levels.label\">series.levels.label</a> &gt; <a href=\"#series-sunburst.label\">series.label</a>。</strong></p>\n<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"rotate":{"type":["string","number"],"description":"\n\n\n<p>同 <a href=\"#sunburst.label.rotate\">label.rotate</a></p>\n","uiControl":{"type":"enum","options":"radial,tangential","default":"radial"},"default":"'radial'"},"align":{"type":["string"],"description":"\n\n<p>Align of text, which can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>. Note that <code class=\"codespan\">&#39;left&#39;</code> stands for inner side, and <code class=\"codespan\">&#39;right&#39;</code> stands for outer side.</p>\n<p>Same to <a href=\"#sunburst.label.align\">label.align</a></p>\n","uiControl":{"type":"enum","options":"left,center,right","default":"center"},"default":"'center'"},"minAngle":{"type":["number"],"description":"\n\n<p>If angle of data piece is smaller than this value (in degrees), then text is not displayed. This is used for hiding text for small piece of data.</p>\n","uiControl":{"type":"angle","min":"0","step":"1","max":"360"},"default":null},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>旭日图扇形块的样式。</p>\n<p>可以在 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 定义所有扇形块的样式，也可以在 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> 定义每一层扇形块的样式，还可以在 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> 定义每个扇形块单独的样式，这三者的优先级从低到高。也就是说，如果定义了 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a>，将会覆盖 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 和 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a>。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> &gt; <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> &gt; <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a>。</strong></p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'white'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"},"default":1}}}}},"select":{"type":["*"],"description":"<p>Configurations of select state. Available when <a href=\"#series-sunburst.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> 描述了每个扇形块中，文本标签的样式。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.label\">series.data.label</a> &gt; <a href=\"#series-sunburst.levels.label\">series.levels.label</a> &gt; <a href=\"#series-sunburst.label\">series.label</a>。</strong></p>\n<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"rotate":{"type":["string","number"],"description":"\n\n\n<p>同 <a href=\"#sunburst.label.rotate\">label.rotate</a></p>\n","uiControl":{"type":"enum","options":"radial,tangential","default":"radial"},"default":"'radial'"},"align":{"type":["string"],"description":"\n\n<p>Align of text, which can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>. Note that <code class=\"codespan\">&#39;left&#39;</code> stands for inner side, and <code class=\"codespan\">&#39;right&#39;</code> stands for outer side.</p>\n<p>Same to <a href=\"#sunburst.label.align\">label.align</a></p>\n","uiControl":{"type":"enum","options":"left,center,right","default":"center"},"default":"'center'"},"minAngle":{"type":["number"],"description":"\n\n<p>If angle of data piece is smaller than this value (in degrees), then text is not displayed. This is used for hiding text for small piece of data.</p>\n","uiControl":{"type":"angle","min":"0","step":"1","max":"360"},"default":null},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>旭日图扇形块的样式。</p>\n<p>可以在 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 定义所有扇形块的样式，也可以在 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> 定义每一层扇形块的样式，还可以在 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> 定义每个扇形块单独的样式，这三者的优先级从低到高。也就是说，如果定义了 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a>，将会覆盖 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 和 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a>。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> &gt; <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> &gt; <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a>。</strong></p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'white'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"},"default":1}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"levels":{"type":["Array"],"description":"<p><strong>Multiple levels</strong></p>\n<p>Sunburst chart has a leveled structure. To make it convenient, we provide a <code class=\"codespan\">levels</code> option, which is an array. The first element of it is for returning to parent node when data mining. The following elements are for levels from center to outside.</p>\n<p>For example, if we don&#39;t want the data mining, and want to set the most inside sector to be red, and text to be blue, we can set the option like:</p>\n<pre><code class=\"lang-js\">series: {\n    // ...\n    levels: [\n        {\n            // Blank setting for data mining\n        },\n        {\n            // The most inside level\n            itemStyle: {\n                color: &#39;red&#39;\n            },\n            label: {\n                color: &#39;blue&#39;\n            }\n        },\n        {\n            // The second level\n        }\n    ]\n}\n</code></pre>\n","items":{"type":"Object","properties":{"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> 描述了每个扇形块中，文本标签的样式。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.label\">series.data.label</a> &gt; <a href=\"#series-sunburst.levels.label\">series.levels.label</a> &gt; <a href=\"#series-sunburst.label\">series.label</a>。</strong></p>\n<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"rotate":{"type":["string","number"],"description":"\n\n\n<p>同 <a href=\"#sunburst.label.rotate\">label.rotate</a></p>\n","uiControl":{"type":"enum","options":"radial,tangential","default":"radial"},"default":"'radial'"},"align":{"type":["string"],"description":"\n\n<p>Align of text, which can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>. Note that <code class=\"codespan\">&#39;left&#39;</code> stands for inner side, and <code class=\"codespan\">&#39;right&#39;</code> stands for outer side.</p>\n<p>Same to <a href=\"#sunburst.label.align\">label.align</a></p>\n","uiControl":{"type":"enum","options":"left,center,right","default":"center"},"default":"'center'"},"minAngle":{"type":["number"],"description":"\n\n<p>If angle of data piece is smaller than this value (in degrees), then text is not displayed. This is used for hiding text for small piece of data.</p>\n","uiControl":{"type":"angle","min":"0","step":"1","max":"360"},"default":null},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>旭日图扇形块的样式。</p>\n<p>可以在 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 定义所有扇形块的样式，也可以在 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> 定义每一层扇形块的样式，还可以在 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> 定义每个扇形块单独的样式，这三者的优先级从低到高。也就是说，如果定义了 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a>，将会覆盖 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 和 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a>。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> &gt; <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> &gt; <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a>。</strong></p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'white'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"},"default":1}}},"emphasis":{"type":["*"],"description":"<p>Emphasis state.</p>\n","properties":{"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> 描述了每个扇形块中，文本标签的样式。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.label\">series.data.label</a> &gt; <a href=\"#series-sunburst.levels.label\">series.levels.label</a> &gt; <a href=\"#series-sunburst.label\">series.label</a>。</strong></p>\n<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"rotate":{"type":["string","number"],"description":"\n\n\n<p>同 <a href=\"#sunburst.label.rotate\">label.rotate</a></p>\n","uiControl":{"type":"enum","options":"radial,tangential","default":"radial"},"default":"'radial'"},"align":{"type":["string"],"description":"\n\n<p>Align of text, which can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>. Note that <code class=\"codespan\">&#39;left&#39;</code> stands for inner side, and <code class=\"codespan\">&#39;right&#39;</code> stands for outer side.</p>\n<p>Same to <a href=\"#sunburst.label.align\">label.align</a></p>\n","uiControl":{"type":"enum","options":"left,center,right","default":"center"},"default":"'center'"},"minAngle":{"type":["number"],"description":"\n\n<p>If angle of data piece is smaller than this value (in degrees), then text is not displayed. This is used for hiding text for small piece of data.</p>\n","uiControl":{"type":"angle","min":"0","step":"1","max":"360"},"default":null},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>旭日图扇形块的样式。</p>\n<p>可以在 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 定义所有扇形块的样式，也可以在 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> 定义每一层扇形块的样式，还可以在 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> 定义每个扇形块单独的样式，这三者的优先级从低到高。也就是说，如果定义了 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a>，将会覆盖 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 和 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a>。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> &gt; <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> &gt; <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a>。</strong></p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'white'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"},"default":1}}}}},"blur":{"type":["*"],"description":"<p>Blur state.</p>\n","properties":{"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> 描述了每个扇形块中，文本标签的样式。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.label\">series.data.label</a> &gt; <a href=\"#series-sunburst.levels.label\">series.levels.label</a> &gt; <a href=\"#series-sunburst.label\">series.label</a>。</strong></p>\n<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"rotate":{"type":["string","number"],"description":"\n\n\n<p>同 <a href=\"#sunburst.label.rotate\">label.rotate</a></p>\n","uiControl":{"type":"enum","options":"radial,tangential","default":"radial"},"default":"'radial'"},"align":{"type":["string"],"description":"\n\n<p>Align of text, which can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>. Note that <code class=\"codespan\">&#39;left&#39;</code> stands for inner side, and <code class=\"codespan\">&#39;right&#39;</code> stands for outer side.</p>\n<p>Same to <a href=\"#sunburst.label.align\">label.align</a></p>\n","uiControl":{"type":"enum","options":"left,center,right","default":"center"},"default":"'center'"},"minAngle":{"type":["number"],"description":"\n\n<p>If angle of data piece is smaller than this value (in degrees), then text is not displayed. This is used for hiding text for small piece of data.</p>\n","uiControl":{"type":"angle","min":"0","step":"1","max":"360"},"default":null},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>旭日图扇形块的样式。</p>\n<p>可以在 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 定义所有扇形块的样式，也可以在 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> 定义每一层扇形块的样式，还可以在 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> 定义每个扇形块单独的样式，这三者的优先级从低到高。也就是说，如果定义了 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a>，将会覆盖 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 和 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a>。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> &gt; <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> &gt; <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a>。</strong></p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'white'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"},"default":1}}}}},"select":{"type":["*"],"description":"<p>Select state.</p>\n","properties":{"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> 描述了每个扇形块中，文本标签的样式。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.label\">series.data.label</a> &gt; <a href=\"#series-sunburst.levels.label\">series.levels.label</a> &gt; <a href=\"#series-sunburst.label\">series.label</a>。</strong></p>\n<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"rotate":{"type":["string","number"],"description":"\n\n\n<p>同 <a href=\"#sunburst.label.rotate\">label.rotate</a></p>\n","uiControl":{"type":"enum","options":"radial,tangential","default":"radial"},"default":"'radial'"},"align":{"type":["string"],"description":"\n\n<p>Align of text, which can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>. Note that <code class=\"codespan\">&#39;left&#39;</code> stands for inner side, and <code class=\"codespan\">&#39;right&#39;</code> stands for outer side.</p>\n<p>Same to <a href=\"#sunburst.label.align\">label.align</a></p>\n","uiControl":{"type":"enum","options":"left,center,right","default":"center"},"default":"'center'"},"minAngle":{"type":["number"],"description":"\n\n<p>If angle of data piece is smaller than this value (in degrees), then text is not displayed. This is used for hiding text for small piece of data.</p>\n","uiControl":{"type":"angle","min":"0","step":"1","max":"360"},"default":null},"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>旭日图扇形块的样式。</p>\n<p>可以在 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 定义所有扇形块的样式，也可以在 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> 定义每一层扇形块的样式，还可以在 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> 定义每个扇形块单独的样式，这三者的优先级从低到高。也就是说，如果定义了 <a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a>，将会覆盖 <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a> 和 <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a>。</p>\n<p><strong>优先级：<a href=\"#series-sunburst.data.itemStyle\">series.data.itemStyle</a> &gt; <a href=\"#series-sunburst.levels.itemStyle\">series.levels.itemStyle</a> &gt; <a href=\"#series-sunburst.itemStyle\">series.itemStyle</a>。</strong></p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'white'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"},"default":1}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"'cubicOut'"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":500},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},{"type":["Object"],"description":"<p><a href=\"https://en.wikipedia.org/wiki/Box_plot\" target=\"_blank\">Boxplot</a> is a convenient way of graphically depicting groups of numerical data through their quartiles.</p>\n<p><strong>Example:</strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=boxplot-light-velocity&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n<p><br>\nMultiple <code class=\"codespan\">series</code> can be displayed in the same coordinate system. Please refer to <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=boxplot-multi&amp;edit=1&amp;reset=1\" target=\"_blank\">this example</a>.</p>\n<p><br>\n<br></p>\n","properties":{"type":{"type":["string"],"description":"","default":"'boxplot'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"coordinateSystem":{"type":["string"],"description":"<p>The coordinate used in the series, whose options are:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;cartesian2d&#39;</code></p>\n<p>  Use a two-dimensional rectangular coordinate (also known as Cartesian coordinate), with <a href=\"#series-cartesian2d.xAxisIndex\">xAxisIndex</a> and <a href=\"#series-cartesian2d.yAxisIndex\">yAxisIndex</a> to assign the corresponding axis component.</p>\n</li>\n</ul>\n","default":"'cartesian2d'"},"xAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#xAxis\">x axis</a> to combine with, which is  useful for multiple x axes in one chart.</p>\n","default":0},"yAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#yAxis\">y axis</a> to combine with, which is  useful for multiple y axes in one chart.</p>\n","default":0},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"legendHoverLink":{"type":["boolean"],"description":"\n\n<p>Whether to enable highlighting chart when <a href=\"#legend\">legend</a> is being hovered.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"hoverAnimation":{"type":["boolean"],"description":"<p>Whether to enable the animation when hovering on box.</p>\n","default":true},"layout":{"type":["string"],"description":"<p>Layout methods, whose optional values are:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;horizontal&#39;</code>: horizontally layout all boxes.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;vertical&#39;</code>: vertically layout all boxes.</p>\n</li>\n</ul>\n<p>The default value is decided by:</p>\n<ul>\n<li>if there is a <code class=\"codespan\">category</code> axis:<ul>\n<li>if it is horizontal, use <code class=\"codespan\">&#39;horizontal&#39;</code>;</li>\n<li>otherwise use <code class=\"codespan\">&#39;vertical&#39;</code>;</li>\n</ul>\n</li>\n<li>otherwise use <code class=\"codespan\">&#39;horizontal&#39;</code>.</li>\n</ul>\n","default":null},"boxWidth":{"type":["Array"],"description":"\n\n<p>Up and bottom boundary of box width. The array is in the form of <code class=\"codespan\">[min, max]</code>.</p>\n<p>It could be absolute value in pixel, such as <code class=\"codespan\">[7, 50]</code>, or percentage, such as <code class=\"codespan\">[&#39;40%&#39;, &#39;90%&#39;]</code>. The percentage means the percentage to the maximum possible width.</p>\n","uiControl":{"type":"percentvector","default":"7,50","min":"0","dims":"min,max"},"default":"[7, 50]"},"itemStyle":{"type":["Object"],"description":"<p>Style of boxplot.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>boxplot color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#fff"},"borderColor":{"type":["Color"],"description":"\n\n<p>boxplot border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>boxplot border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"emphasis":{"type":["Object"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>boxplot color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#fff"},"borderColor":{"type":["Color"],"description":"\n\n<p>boxplot border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>boxplot border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"2","min":"0","step":"0.5"},"default":2},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":"rgba(0,0,0,0.2)"},"default":"rgba(0,0,0,0.2)"},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"1","step":"0.5"},"default":1},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"1","step":"0.5"},"default":1},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Available when <a href=\"#series-boxplot.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>boxplot color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p>boxplot border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>boxplot border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of select state. Available when <a href=\"#series-boxplot.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>boxplot color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p>boxplot border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>boxplot border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"dimensions":{"type":["Array"],"description":"<p><code class=\"codespan\">dimensions</code> can be used to define dimension info for <code class=\"codespan\">series.data</code> or <code class=\"codespan\">dataset.source</code>.</p>\n<p>Notice: if <a href=\"#dataset\">dataset</a> is used, we can definite dimensions in <a href=\"#dataset.dimensions\">dataset.dimensions</a>, or provide dimension names in the first column/row of <a href=\"#dataset.source\">dataset.source</a>, and not need to specify <code class=\"codespan\">dimensions</code> here. But if <code class=\"codespan\">dimensions</code> is specified here, it will be used despite the dimension definitions in dataset.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // &#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        // Specify name for each dimesions, which will be displayed in tooltip.\n        dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [\n        null,                // If you do not intent to defined this dimension, use null is fine.\n        {type: &#39;ordinal&#39;},   // Specify type of this dimension.\n                             // &#39;ordinal&#39; is always used in string.\n                             // If type is not specified, echarts will guess type by data.\n        {name: &#39;good&#39;, type: &#39;number&#39;},\n        &#39;bad&#39;                // Equals to {name: &#39;bad&#39;}.\n    ]\n}\n</code></pre>\n<p>Each data item of <code class=\"codespan\">dimensions</code> can be:</p>\n<ul>\n<li><code class=\"codespan\">string</code>, for example, <code class=\"codespan\">&#39;someName&#39;</code>, which equals to <code class=\"codespan\">{name: &#39;someName&#39;}</code>.</li>\n<li><code class=\"codespan\">Object</code>, where the attributes can be:<ul>\n<li>name: <code class=\"codespan\">string</code>.</li>\n<li>type: <code class=\"codespan\">string</code>, supports:<ul>\n<li><code class=\"codespan\">number</code></li>\n<li><code class=\"codespan\">float</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array\" target=\"_blank\">Float64Array</a></li>\n<li><code class=\"codespan\">int</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array\" target=\"_blank\">Int32Array</a></li>\n<li><code class=\"codespan\">ordinal</code>, discrete value, which represents string generally.</li>\n<li><code class=\"codespan\">time</code>, time value, see <a href=\"#series.data\">data</a> to check the format of time value.</li>\n</ul>\n</li>\n<li>displayName: <code class=\"codespan\">string</code>, generally used in tooltip for dimension display. If not specified, use <code class=\"codespan\">name</code> by default.</li>\n</ul>\n</li>\n</ul>\n<p>When <code class=\"codespan\">dimensions</code> is specified, the default <code class=\"codespan\">tooltip</code> will be displayed vertically, which is better to show diemsion names. Otherwise, <code class=\"codespan\">tooltip</code> will displayed only value horizontally.</p>\n"},"encode":{"type":["Object"],"description":"<p>Define what is encoded to for each dimension of <code class=\"codespan\">data</code>. For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // Each column is called a dimension.\n            // There are five dimensions: 0, 1, 2, 3, 4.\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        encode: {\n            x: [3, 1, 5],      // Dimension 3, 1, 5 is mapped to x axis.\n            y: 2,              // Dimension 2 is mapped to y axis.\n            tooltip: [3, 2, 4] // Dimension 3, 2, 4 will be displayed in tooltip.\n        }\n    }\n}\n</code></pre>\n<p>When <a href=\"#series.dimensions\">dimensions</a> is used to defined name for a certain dimension, <code class=\"codespan\">encode</code> can refer the name directly. For example:</p>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;],\n    encode: {\n        x: &#39;date&#39;,\n        y: [&#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<p>The basic structure of <a href=\"option.html#series.encode\" target=\"_blank\">encode</a> is illustrated as follows, where the left part of colon is the name of axis like <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code> or some special reserved names like &quot;tooltip&quot;, &quot;itemName&quot; etc., and the right part of the colon is the dimension names or dimension indices (based on 0). One or more dimensions can be specified. Usually not all of mappings need to be specified, only specify needed ones.</p>\n<p>The properties available in <code class=\"codespan\">encode</code> listed as follows:</p>\n<pre><code class=\"lang-js\">// In any of the series and coordinate systems,\n// these properties are available:\nencode: {\n    // Display dimension &quot;product&quot; and &quot;score&quot; in the tooltip.\n    tooltip: [&#39;product&#39;, &#39;score&#39;]\n    // Set the series name as the concat of the names of dimensions[1] and dimensions[3].\n    // (sometimes the dimension names are too long to type in series.name manually).\n    seriesName: [1, 3],\n    // Using dimensions[2] as the id of each data item. This is useful when dynamically\n    // update data by `chart.setOption()`, where the new and old data item can be\n    // corresponded by id, by which the appropriate animation can be performed when updating.\n    itemId: 2,\n    // Using dimensions[3] as the name of each data item. This is useful in charts like\n    // &#39;pie&#39;, &#39;funnel&#39;, where data item name can be displayed in legend.\n    itemName: 3\n}\n\n// These properties only work in cartesian(grid) coordinate system:\nencode: {\n    // Map dimensions[1], dimensions[5] and dimension &quot;score&quot; to the X axis.\n    x: [1, 5, &#39;score&#39;],\n    // Map dimensions[0] to the Y axis.\n    y: 0\n}\n\n// These properties only work in polar coordinate system:\nencode: {\n    radius: 3,\n    angle: 2,\n    ...\n}\n\n// These properties only work in geo coordinate system:\nencode: {\n    lng: 3,\n    lat: 2\n}\n\n// For some type of series that are not in any coordinate system,\n// like &#39;pie&#39;, &#39;funnel&#39; etc.:\nencode: {\n    value: 3\n}\n</code></pre>\n<p>This is an <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=dataset-encode1&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> for <code class=\"codespan\">encode</code>.</p>\n<p>Specially, in [custom series(~series-custom), some property in <code class=\"codespan\">encode</code>, corresponding to axis, can be set as null to make the series not controlled by the axis, that is, the series data will not be count in the extent of the axis, and the <a href=\"#dataZoom\">dataZoom</a> on the axis will not filter the series.</p>\n<pre><code class=\"lang-js\">var option = {\n    xAxis: {},\n    yAxis: {},\n    dataZoom: [{\n        xAxisIndex: 0\n    }, {\n        yAxisIndex: 0\n    }],\n    series: {\n        type: &#39;custom&#39;,\n        renderItem: function (params, api) {\n            return {\n                type: &#39;circle&#39;,\n                shape: {\n                    cx: 100, // x position is always 100\n                    cy: api.coord([0, api.value(0)])[1],\n                    r: 30\n                },\n                style: {\n                    fill: &#39;blue&#39;\n                }\n            };\n        },\n        encode: {\n            // Then the series will not be controlled\n            // by x axis and corresponding dataZoom.\n            x: -1,\n            y: 1\n        },\n        data: [ ... ]\n    }\n};\n</code></pre>\n"},"data":{"type":["Array"],"description":"<p>Data should be the two-dimensional array shown as follow.</p>\n<pre><code class=\"lang-javascript\">[\n    [655, 850, 940, 980, 1175],\n    [672.5, 800, 845, 885, 1012.5],\n    [780, 840, 855, 880, 940],\n    [621.25, 767.5, 815, 865, 1011.25],\n    { // the data item could also be an Object, so that it could contains special settings for this data item.\n        value: [713.75, 807.5, 810, 870, 963.75],\n        itemStyle: {...}\n    },\n    ...\n]\n</code></pre>\n<p>Every data item (each line in the example above) in the two-dimensional array will be rendered into a box, and each line have five values as:</p>\n<pre><code class=\"lang-javascript\">[min,  Q1,  median (or Q2),  Q3,  max]\n</code></pre>\n<p><strong>Data Processing</strong></p>\n<p>ECharts doesn&#39;t contain data processing modules, so the five statistic values should be calculated by yourself and then passes into <code class=\"codespan\">boxplot</code>.</p>\n<p>However, ECharts also provide some simple <a href=\"https://github.com/apache/echarts/tree/master/extension/dataTool\" target=\"_blank\">raw data processing tools</a>. For example, this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=boxplot-light-velocity&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> uses <code class=\"codespan\">echarts.dataTool.prepareBoxplotData</code> to proceed simple data statistics.</p>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Name of data item.</p>\n"},"value":{"type":["Array"],"description":"<p>Value of data item.</p>\n<pre><code class=\"lang-javascript\">[min,  Q1,  median (or Q2),  Q3,  max]\n</code></pre>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of a single data.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>boxplot color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p>boxplot border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>boxplot border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of a single data.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>boxplot color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p>boxplot border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>boxplot border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state of single data.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>boxplot color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p>boxplot border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>boxplot border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state of single data.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>boxplot color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p>boxplot border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>boxplot border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n<p>It works only if <code class=\"codespan\">areaStyle</code> is set.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series data.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}}},"markPoint":{"type":["Object"],"description":"<p>Mark point in a chart.</p>\n","properties":{"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-boxplot.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'pin'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-boxplot.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":50},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-boxplot.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label of mark point.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark point.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Data array for mark points, each of which is an object. Here are some ways to assign mark point position.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-boxplot.markPoint.data.x\">x</a>, <a href=\"#series-boxplot.markPoint.data.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li><p>Assign coordinate position with <a href=\"#series-boxplot.markPoint.data.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</p>\n</li>\n<li><p>Use <a href=\"#series-boxplot.markPoint.data.type\">type</a> attribute to mark the maximum and minimum values in the series, in which <a href=\"#series-boxplot.markPoint.data.valueIndex\">valueIndex</a> or <a href=\"#series-boxplot.markPoint.data.valueDim\">valueDim</a> can be used to assign the dimension.</p>\n</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p><strong>For example: </strong></p>\n<pre><code class=\"lang-js\">data: [\n    {\n        name: &#39;maximum&#39;,\n        type: &#39;max&#39;\n    }, \n    {\n        name: &#39;coordinate&#39;,\n        coord: [10, 20]\n    }, {\n        name: &#39;fixed x position&#39;,\n        yAxis: 10,\n        x: &#39;90%&#39;\n    }, \n\n    {\n        name: &#39;screen coordinate&#39;,\n        x: 100,\n        y: 100\n    }\n]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Mark point name.</p>\n","default":"''"},"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Available when using <a href=\"#series-boxplot.markPoint.data.type\">type</a> it is used to assign maximum value and minimum value in dimensions, it could be <code class=\"codespan\">0</code> (xAxis, radiusAxis), <code class=\"codespan\">1</code> (yAxis, angleAxis), and use the first value axis dimension by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-boxplot.markPoint.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markLine":{"type":["Object"],"description":"<p>Use a line in the chart to illustrate.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"symbol":{"type":["string","Array"],"description":"<p>Symbol type at the two ends of the mark line. It can be an array for two ends, or assigned seperately. See <a href=\"#series-boxplot.markLine.data.0.symbol\">data.symbol</a> for more format information.</p>\n"},"symbolSize":{"type":["number","Array"],"description":"<p>Symbol size at the two ends of the mark line. It can be an array for two ends, or assigned seperately.</p>\n<p><strong>Attention: </strong> You cannot assgin width and height seperately as normal <code class=\"codespan\">symbolSize</code>.</p>\n"},"precision":{"type":["number"],"description":"<p>Precision of marking line value, which is useful when displaying average value mark line.</p>\n","default":2},"label":{"type":["Object"],"description":"<p>Mark line text.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"<p>Mark line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark line.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>Data array of marking line. Every array item can be an array of one or two values, representing starting and ending point of the line, and every item is an object. Here are several ways to assign the positions of starting and ending point.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-boxplot.markLine.data.0.x\">x</a>, <a href=\"#series-boxplot.markLine.data.0.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li><p>Assign coordinate position with <a href=\"#series-boxplot.markLine.data.0.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</p>\n</li>\n<li><p>Use <a href=\"#series-boxplot.markLine.data.0.type\">type</a> attribute to mark the maximum and minimum values in the series, in which <a href=\"#series-boxplot.markLine.data.0.valueIndex\">valueIndex</a> or <a href=\"#series-boxplot.markLine.data.0.valueDim\">valueDim</a> can be used to assign the dimension.</p>\n</li>\n<li><p>You may also create a mark line in Cartesian coordinate at a specific position in X or Y axis by assigning <code class=\"codespan\">xAxis</code> or <code class=\"codespan\">yAxis</code>. See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-weight\" target=\"_blank\">scatter-weight</a> for example.</p>\n</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p>You may also set the type of mark line through <code class=\"codespan\">type</code>, stating whether it is for the maximum value or average value. Likewise, dimensions can be assigned through <code class=\"codespan\">valueIndex</code>.</p>\n<pre><code>data: [\n\n{\n        name: &#39;average line&#39;,\n        // &#39;average&#39;, &#39;min&#39;, and &#39;max&#39; are supported\n        type: &#39;average&#39;\n    },\n    {\n        name: &#39;Horizontal line with Y value at 100&#39;,\n        yAxis: 100\n    },\n    [\n        {\n            // Use the same name with starting and ending point\n            name: &#39;Minimum to Maximum&#39;,\n            type: &#39;min&#39;\n        },\n        {\n            type: &#39;max&#39;\n        }\n    ],\n[\n        {\n            name: &#39;Markline between two points&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [{\n        // Mark line with a fixed X position in starting point. This is used to generate an arrow pointing to maximum line.\n        yAxis: &#39;max&#39;,\n        x: &#39;90%&#39;\n    }, {\n        type: &#39;max&#39;\n    }],\n[\n        {\n            name: &#39;Mark line between two points&#39;,\n            x: 100,\n            y: 100\n        },\n        {\n            x: 500,\n            y: 200\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Data of the starting point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n<li><code class=\"codespan\">&#39;median&#39;</code> median value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-boxplot.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-boxplot.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'starting point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of starting point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>starting point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of starting point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of starting point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Data of the ending point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n<li><code class=\"codespan\">&#39;median&#39;</code> median value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-boxplot.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-boxplot.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'ending point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of ending point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>ending point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of ending point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of ending point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markArea":{"type":["Object"],"description":"<p>Used to mark an area in chart. For example, mark a time interval.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label in mark area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Style of the mark area.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark area.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>The scope of the area is defined by <code class=\"codespan\">data</code>, which is an array with two item, representing the left-top point and the right-bottom point of rectangle area. Each item can be defined as follows:</p>\n<ol>\n<li>Specify the coordinate in screen coordinate system using <a href=\"#series-boxplot.markArea.data.0.x\">x</a>, <a href=\"#series-boxplot.markArea.data.0.y\">y</a>, where the unit is pixel (e.g., the value is <code class=\"codespan\">5</code>), or percent (e.g., the value is <code class=\"codespan\">&#39;35%&#39;</code>).</li>\n</ol>\n<ol start=\"2\">\n<li><p>Specify the coordinate in data coordinate system (i.e., cartesian) using\n<a href=\"#series-boxplot.markArea.data.0.coord\">coord</a>, which can be also set as <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> (e.g, <code class=\"codespan\">coord: [23, &#39;min&#39;]</code>, or <code class=\"codespan\">coord: [&#39;average&#39;, &#39;max&#39;]</code>).</p>\n</li>\n<li><p>Locate the point on the min value or max value of <code class=\"codespan\">series.data</code> using <a href=\"#series-boxplot.markArea.data.0.type\">type</a>, where <a href=\"#series-boxplot.markArea.data.0.valueIndex\">valueIndex</a> or <a href=\"#series-boxplot.markPoint.data.0.valueDim\">valueDim</a> can be used to specify the dimension on which the min, max or average are calculated.</p>\n</li>\n<li>If in cartesian, you can only specify <code class=\"codespan\">xAxis</code> or <code class=\"codespan\">yAxis</code> to define a mark area based on only X or Y axis, see sample <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-weight\" target=\"_blank\">scatter-weight</a></li>\n</ol>\n<p>The priority follows as above if more than one above definition used.</p>\n<pre><code>data: [\n\n\n    [\n        {\n            name: &#39;From average to max&#39;,\n            type: &#39;average&#39;\n        },\n        {\n            type: &#39;max&#39;\n        }\n    ],\n\n    [\n        {\n            name: &#39;Mark area between two points in data coordiantes&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [\n        {\n            name: &#39;From 60 to 80&#39;,\n            yAxis: 60\n        },\n        {\n            yAxis: 80\n        }\n    ], [\n        {\n            name: &#39;Mark area covers all data&#39;\n            coord: [&#39;min&#39;, &#39;min&#39;]\n        },\n        {\n            coord: [&#39;max&#39;, &#39;max&#39;]\n        }\n    ],\n[\n        {\n            name: &#39;Mark area in two screen points&#39;,\n            x: 100,\n            y: 100\n        }, {\n            x: &#39;90%&#39;,\n            y: &#39;10%&#39;\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Specify the left-top point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Specify this item is on min or max or average value.</p>\n<p><strong>Options:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> max value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> min value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-boxplot.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-boxplot.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'start'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Specify the right-bottom point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Specify this item is on min or max or average value.</p>\n<p><strong>Options:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> max value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> min value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-boxplot.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-boxplot.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'end'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"false","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in Boxplot .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in Boxplot , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"800","step":"20","clean":"true"},"default":800},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"elasticOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p>A <a href=\"https://en.wikipedia.org/wiki/Candlestick_chart\" target=\"_blank\">candlestick</a> chart (also called Japanese candlestick chart) is a style of financial chart used to describe price movements of a security, derivative, or currency.</p>\n<p>ECharts3 supports both <code class=\"codespan\">&#39;candlestick&#39;</code> and <code class=\"codespan\">&#39;k&#39;</code> in <a href=\"#(series.type\">series.type</a> (<code class=\"codespan\">&#39;k&#39;</code> would automatically turns into <code class=\"codespan\">&#39;candlestick&#39;</code>).</p>\n<p><strong>An example:</strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=candlestick-sh&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n\n<p><br>\n<strong>About color of increase and decrease</strong></p>\n<p>Different countries or regions have different implications on the color of candle stick chart. It may use red to imply increasing with red and decreasing with blue (in China mainland, Taiwan, Japan, Koera, and so on), or to imply increasing with green and decreasing with red (in Europe, North America, Hong Kong, Singapore, and so on). Besides color, the increase and decrease of stock may also be represented with candle stick with or without filling colors.</p>\n<p>We use red to represent increasing and blue decreasing by default. If you want to change the configuration, you may change the following parameters.</p>\n<ul>\n<li><a href=\"#series-candlestick.itemStyle.color\">series-candlestick.itemStyle.color</a>: fill color for bullish candle stick (namely, increase)</li>\n<li><a href=\"#series-candlestick.itemStyle.color0\">series-candlestick.itemStyle.color0</a>: fill color for bearish candle stick (namely, decrease)</li>\n<li><a href=\"#series-candlestick.itemStyle.borderColor\">series-candlestick.itemStyle.borderColor</a>: border color for bullish candle stick (namely, increase)</li>\n<li><a href=\"series-candlestick.itemStyle.borderColor0\" target=\"_blank\">series-candlestick.itemStyle.borderColor0</a>: border color for bearish candle stick (namely, decrease)</li>\n</ul>\n<p><br>\n<br></p>\n","properties":{"type":{"type":["string"],"description":"","default":"'candlestick'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"coordinateSystem":{"type":["string"],"description":"<p>The coordinate used in the series, whose options are:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;cartesian2d&#39;</code></p>\n<p>  Use a two-dimensional rectangular coordinate (also known as Cartesian coordinate), with <a href=\"#series-cartesian2d.xAxisIndex\">xAxisIndex</a> and <a href=\"#series-cartesian2d.yAxisIndex\">yAxisIndex</a> to assign the corresponding axis component.</p>\n</li>\n</ul>\n","default":"'cartesian2d'"},"xAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#xAxis\">x axis</a> to combine with, which is  useful for multiple x axes in one chart.</p>\n","default":0},"yAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#yAxis\">y axis</a> to combine with, which is  useful for multiple y axes in one chart.</p>\n","default":0},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"legendHoverLink":{"type":["boolean"],"description":"\n\n<p>Whether to enable highlighting chart when <a href=\"#legend\">legend</a> is being hovered.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"hoverAnimation":{"type":["boolean"],"description":"<p>Whether to enable animation when hovering on box.</p>\n","default":true},"layout":{"type":["string"],"description":"<p>Layout method, whose values may be:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;horizontal&#39;</code>: horizontally layout all boxs.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;vertical&#39;</code>: vertically layout all boxs.</p>\n</li>\n</ul>\n<p>The default value is decided by:</p>\n<ul>\n<li>if there is a <code class=\"codespan\">category</code> axis:<ul>\n<li>if it is horizontal, use <code class=\"codespan\">&#39;horizontal&#39;</code>;</li>\n<li>otherwise use <code class=\"codespan\">&#39;vertical&#39;</code>;</li>\n</ul>\n</li>\n<li>otherwise use <code class=\"codespan\">&#39;horizontal&#39;</code>.</li>\n</ul>\n","default":null},"barWidth":{"type":["number"],"description":"\n\n<p>Specify bar width. Absolute value (like <code class=\"codespan\">10</code>) or percentage (like <code class=\"codespan\">&#39;20%&#39;</code>, according to band width) can be used. Auto adapt by default.</p>\n","uiControl":{"type":"percent","default":"70%","min":"0"}},"barMinWidth":{"type":["number","string"],"description":"<p>Specify bar min width. Absolute value (like <code class=\"codespan\">10</code>) or percentage (like <code class=\"codespan\">&#39;20%&#39;</code>, according to band width) can be used. Auto adapt by default.</p>\n"},"barMaxWidth":{"type":["number","string"],"description":"<p>Specify bar max width. Absolute value (like <code class=\"codespan\">10</code>) or percentage (like <code class=\"codespan\">&#39;20%&#39;</code>, according to band width) can be used. Auto adapt by default.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Item style of candlestick.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#c23531"},"color0":{"type":["Color"],"description":"\n\n<p>Fill color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#314656"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#c23531"},"borderColor0":{"type":["Color"],"description":"\n\n<p>Border color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#314656"},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of candlestick. There is no border when it is <code class=\"codespan\">0</code>.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"1"},"default":1},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis style of candlestick.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"color0":{"type":["Color"],"description":"\n\n<p>Fill color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderColor0":{"type":["Color"],"description":"\n\n<p>Border color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of candlestick. There is no border when it is <code class=\"codespan\">0</code>.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"2"},"default":2},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Available when <a href=\"#series-candlestick.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"color0":{"type":["Color"],"description":"\n\n<p>Fill color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderColor0":{"type":["Color"],"description":"\n\n<p>Border color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of candlestick. There is no border when it is <code class=\"codespan\">0</code>.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"2"},"default":2},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of select state. Available when <a href=\"#series-candlestick.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"color0":{"type":["Color"],"description":"\n\n<p>Fill color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderColor0":{"type":["Color"],"description":"\n\n<p>Border color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of candlestick. There is no border when it is <code class=\"codespan\">0</code>.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":"2"},"default":2},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"large":{"type":["boolean"],"description":"\n\n<p>Whether to enable the optimization of large-scale data. It could be set when large data causes performance problem.</p>\n<p>After being enabled, <code class=\"codespan\">largeThreshold</code> can be used to indicate the minimum number for turning on the optimization.</p>\n<p>But when the optimization enabled, the style of single data item can&#39;t be customized any more.</p>\n","uiControl":{"type":"boolean"},"default":true},"largeThreshold":{"type":["number"],"description":"\n\n<p>The threshold enabling the drawing optimization.</p>\n","uiControl":{"type":"number","min":"1","default":"600"},"default":600},"progressive":{"type":["number"],"description":"<p><code class=\"codespan\">progressive</code> specifies the amount of graphic elements that can be rendered within a frame (about 16ms) if &quot;progressive rendering&quot; enabled.</p>\n<p>When data amount is from thousand to more than 10 million, it will take too long time to render all of the graphic elements. Since ECharts 4, &quot;progressive rendering&quot; is supported in its workflow, which processes and renders data chunk by chunk alone with each frame, avoiding to block the UI thread of the browser.</p>\n<p>Set <code class=\"codespan\">progressive: 0</code> to disable progressive permanently. By default, progressive is auto-enabled when data amount is bigger than <code class=\"codespan\">progressiveThreshold</code>.</p>\n","default":3000},"progressiveThreshold":{"type":["number"],"description":"<p>If current data amount is over the threshold, &quot;progressive rendering&quot; is enabled.</p>\n","default":10000},"progressiveChunkMode":{"type":["string"],"description":"<p>Chunk approach, optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;sequential&#39;</code>: slice data by data index.</li>\n<li><code class=\"codespan\">&#39;mod&#39;</code>: slice data by mod, which make the data items of each chunk coming from all over the data, bringing better visual effect while progressive rendering.</li>\n</ul>\n","default":"mod"},"dimensions":{"type":["Array"],"description":"<p><code class=\"codespan\">dimensions</code> can be used to define dimension info for <code class=\"codespan\">series.data</code> or <code class=\"codespan\">dataset.source</code>.</p>\n<p>Notice: if <a href=\"#dataset\">dataset</a> is used, we can definite dimensions in <a href=\"#dataset.dimensions\">dataset.dimensions</a>, or provide dimension names in the first column/row of <a href=\"#dataset.source\">dataset.source</a>, and not need to specify <code class=\"codespan\">dimensions</code> here. But if <code class=\"codespan\">dimensions</code> is specified here, it will be used despite the dimension definitions in dataset.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // &#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        // Specify name for each dimesions, which will be displayed in tooltip.\n        dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [\n        null,                // If you do not intent to defined this dimension, use null is fine.\n        {type: &#39;ordinal&#39;},   // Specify type of this dimension.\n                             // &#39;ordinal&#39; is always used in string.\n                             // If type is not specified, echarts will guess type by data.\n        {name: &#39;good&#39;, type: &#39;number&#39;},\n        &#39;bad&#39;                // Equals to {name: &#39;bad&#39;}.\n    ]\n}\n</code></pre>\n<p>Each data item of <code class=\"codespan\">dimensions</code> can be:</p>\n<ul>\n<li><code class=\"codespan\">string</code>, for example, <code class=\"codespan\">&#39;someName&#39;</code>, which equals to <code class=\"codespan\">{name: &#39;someName&#39;}</code>.</li>\n<li><code class=\"codespan\">Object</code>, where the attributes can be:<ul>\n<li>name: <code class=\"codespan\">string</code>.</li>\n<li>type: <code class=\"codespan\">string</code>, supports:<ul>\n<li><code class=\"codespan\">number</code></li>\n<li><code class=\"codespan\">float</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array\" target=\"_blank\">Float64Array</a></li>\n<li><code class=\"codespan\">int</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array\" target=\"_blank\">Int32Array</a></li>\n<li><code class=\"codespan\">ordinal</code>, discrete value, which represents string generally.</li>\n<li><code class=\"codespan\">time</code>, time value, see <a href=\"#series.data\">data</a> to check the format of time value.</li>\n</ul>\n</li>\n<li>displayName: <code class=\"codespan\">string</code>, generally used in tooltip for dimension display. If not specified, use <code class=\"codespan\">name</code> by default.</li>\n</ul>\n</li>\n</ul>\n<p>When <code class=\"codespan\">dimensions</code> is specified, the default <code class=\"codespan\">tooltip</code> will be displayed vertically, which is better to show diemsion names. Otherwise, <code class=\"codespan\">tooltip</code> will displayed only value horizontally.</p>\n"},"encode":{"type":["Object"],"description":"<p>Define what is encoded to for each dimension of <code class=\"codespan\">data</code>. For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // Each column is called a dimension.\n            // There are five dimensions: 0, 1, 2, 3, 4.\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        encode: {\n            x: [3, 1, 5],      // Dimension 3, 1, 5 is mapped to x axis.\n            y: 2,              // Dimension 2 is mapped to y axis.\n            tooltip: [3, 2, 4] // Dimension 3, 2, 4 will be displayed in tooltip.\n        }\n    }\n}\n</code></pre>\n<p>When <a href=\"#series.dimensions\">dimensions</a> is used to defined name for a certain dimension, <code class=\"codespan\">encode</code> can refer the name directly. For example:</p>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;],\n    encode: {\n        x: &#39;date&#39;,\n        y: [&#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<p>The basic structure of <a href=\"option.html#series.encode\" target=\"_blank\">encode</a> is illustrated as follows, where the left part of colon is the name of axis like <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code> or some special reserved names like &quot;tooltip&quot;, &quot;itemName&quot; etc., and the right part of the colon is the dimension names or dimension indices (based on 0). One or more dimensions can be specified. Usually not all of mappings need to be specified, only specify needed ones.</p>\n<p>The properties available in <code class=\"codespan\">encode</code> listed as follows:</p>\n<pre><code class=\"lang-js\">// In any of the series and coordinate systems,\n// these properties are available:\nencode: {\n    // Display dimension &quot;product&quot; and &quot;score&quot; in the tooltip.\n    tooltip: [&#39;product&#39;, &#39;score&#39;]\n    // Set the series name as the concat of the names of dimensions[1] and dimensions[3].\n    // (sometimes the dimension names are too long to type in series.name manually).\n    seriesName: [1, 3],\n    // Using dimensions[2] as the id of each data item. This is useful when dynamically\n    // update data by `chart.setOption()`, where the new and old data item can be\n    // corresponded by id, by which the appropriate animation can be performed when updating.\n    itemId: 2,\n    // Using dimensions[3] as the name of each data item. This is useful in charts like\n    // &#39;pie&#39;, &#39;funnel&#39;, where data item name can be displayed in legend.\n    itemName: 3\n}\n\n// These properties only work in cartesian(grid) coordinate system:\nencode: {\n    // Map dimensions[1], dimensions[5] and dimension &quot;score&quot; to the X axis.\n    x: [1, 5, &#39;score&#39;],\n    // Map dimensions[0] to the Y axis.\n    y: 0\n}\n\n// These properties only work in polar coordinate system:\nencode: {\n    radius: 3,\n    angle: 2,\n    ...\n}\n\n// These properties only work in geo coordinate system:\nencode: {\n    lng: 3,\n    lat: 2\n}\n\n// For some type of series that are not in any coordinate system,\n// like &#39;pie&#39;, &#39;funnel&#39; etc.:\nencode: {\n    value: 3\n}\n</code></pre>\n<p>This is an <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=dataset-encode1&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> for <code class=\"codespan\">encode</code>.</p>\n<p>Specially, in [custom series(~series-custom), some property in <code class=\"codespan\">encode</code>, corresponding to axis, can be set as null to make the series not controlled by the axis, that is, the series data will not be count in the extent of the axis, and the <a href=\"#dataZoom\">dataZoom</a> on the axis will not filter the series.</p>\n<pre><code class=\"lang-js\">var option = {\n    xAxis: {},\n    yAxis: {},\n    dataZoom: [{\n        xAxisIndex: 0\n    }, {\n        yAxisIndex: 0\n    }],\n    series: {\n        type: &#39;custom&#39;,\n        renderItem: function (params, api) {\n            return {\n                type: &#39;circle&#39;,\n                shape: {\n                    cx: 100, // x position is always 100\n                    cy: api.coord([0, api.value(0)])[1],\n                    r: 30\n                },\n                style: {\n                    fill: &#39;blue&#39;\n                }\n            };\n        },\n        encode: {\n            // Then the series will not be controlled\n            // by x axis and corresponding dataZoom.\n            x: -1,\n            y: 1\n        },\n        data: [ ... ]\n    }\n};\n</code></pre>\n"},"data":{"type":["Array"],"description":"<p>Data should be the two-dimensional array shown as follows.</p>\n<pre><code class=\"lang-javascript\">[\n    [2320.26, 2320.26, 2287.3,  2362.94],\n    [2300,    2291.3,  2288.26, 2308.38],\n    { // the data item could also be an Object, so that it could contains special settings for this data item.\n        value: [2300,    2291.3,  2288.26, 2308.38],\n        itemStyle: {...}\n    },\n    ...\n]\n</code></pre>\n<p>Every data item (each line in the example above) represents a box, which contains 4 values. They are:</p>\n<pre><code class=\"lang-javascript\">[open, close, lowest, highest]  (namely: [opening value, closing value, lowest value, highest value])\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Name of data item.</p>\n"},"value":{"type":["Array"],"description":"<p>Value of data item.</p>\n<pre><code class=\"lang-javascript\">[open, close, lowest, highest]  (namely: [opening value, closing value, lowest value, highest value])\n</code></pre>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of a candle box.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"color0":{"type":["Color"],"description":"\n\n<p>Fill color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderColor0":{"type":["Color"],"description":"\n\n<p>Border color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of candlestick. There is no border when it is <code class=\"codespan\">0</code>.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":""}},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis style of a candle box.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"color0":{"type":["Color"],"description":"\n\n<p>Fill color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderColor0":{"type":["Color"],"description":"\n\n<p>Border color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of candlestick. There is no border when it is <code class=\"codespan\">0</code>.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":""}},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state of single data.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"color0":{"type":["Color"],"description":"\n\n<p>Fill color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderColor0":{"type":["Color"],"description":"\n\n<p>Border color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of candlestick. There is no border when it is <code class=\"codespan\">0</code>.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":""}},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state of single data.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Fill color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"color0":{"type":["Color"],"description":"\n\n<p>Fill color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of bullish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderColor0":{"type":["Color"],"description":"\n\n<p>Border color of bearish candle stick.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of candlestick. There is no border when it is <code class=\"codespan\">0</code>.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5","default":""}},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series data.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}}},"markPoint":{"type":["Object"],"description":"<p>Mark point in a chart.</p>\n","properties":{"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-candlestick.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'pin'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-candlestick.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":50},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-candlestick.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label of mark point.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark point.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Data array for mark points, each of which is an object. Here are some ways to assign mark point position.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-candlestick.markPoint.data.x\">x</a>, <a href=\"#series-candlestick.markPoint.data.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li><p>Assign coordinate position with <a href=\"#series-candlestick.markPoint.data.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</p>\n</li>\n<li><p>Use <a href=\"#series-candlestick.markPoint.data.type\">type</a> attribute to mark the maximum and minimum values in the series, in which <a href=\"#series-candlestick.markPoint.data.valueIndex\">valueIndex</a> or <a href=\"#series-candlestick.markPoint.data.valueDim\">valueDim</a> can be used to assign the dimension.</p>\n</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p><strong>For example: </strong></p>\n<pre><code class=\"lang-js\">data: [\n    {\n        name: &#39;maximum&#39;,\n        type: &#39;max&#39;\n    }, \n    {\n        name: &#39;coordinate&#39;,\n        coord: [10, 20]\n    }, {\n        name: &#39;fixed x position&#39;,\n        yAxis: 10,\n        x: &#39;90%&#39;\n    }, \n\n    {\n        name: &#39;screen coordinate&#39;,\n        x: 100,\n        y: 100\n    }\n]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Mark point name.</p>\n","default":"''"},"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Available when using <a href=\"#series-candlestick.markPoint.data.type\">type</a> it is used to assign maximum value and minimum value in dimensions, it could be <code class=\"codespan\">0</code> (xAxis, radiusAxis), <code class=\"codespan\">1</code> (yAxis, angleAxis), and use the first value axis dimension by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-candlestick.markPoint.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markLine":{"type":["Object"],"description":"<p>Use a line in the chart to illustrate.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"symbol":{"type":["string","Array"],"description":"<p>Symbol type at the two ends of the mark line. It can be an array for two ends, or assigned seperately. See <a href=\"#series-candlestick.markLine.data.0.symbol\">data.symbol</a> for more format information.</p>\n"},"symbolSize":{"type":["number","Array"],"description":"<p>Symbol size at the two ends of the mark line. It can be an array for two ends, or assigned seperately.</p>\n<p><strong>Attention: </strong> You cannot assgin width and height seperately as normal <code class=\"codespan\">symbolSize</code>.</p>\n"},"precision":{"type":["number"],"description":"<p>Precision of marking line value, which is useful when displaying average value mark line.</p>\n","default":2},"label":{"type":["Object"],"description":"<p>Mark line text.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"<p>Mark line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark line.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>Data array of marking line. Every array item can be an array of one or two values, representing starting and ending point of the line, and every item is an object. Here are several ways to assign the positions of starting and ending point.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-candlestick.markLine.data.0.x\">x</a>, <a href=\"#series-candlestick.markLine.data.0.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li><p>Assign coordinate position with <a href=\"#series-candlestick.markLine.data.0.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</p>\n</li>\n<li><p>Use <a href=\"#series-candlestick.markLine.data.0.type\">type</a> attribute to mark the maximum and minimum values in the series, in which <a href=\"#series-candlestick.markLine.data.0.valueIndex\">valueIndex</a> or <a href=\"#series-candlestick.markLine.data.0.valueDim\">valueDim</a> can be used to assign the dimension.</p>\n</li>\n<li><p>You may also create a mark line in Cartesian coordinate at a specific position in X or Y axis by assigning <code class=\"codespan\">xAxis</code> or <code class=\"codespan\">yAxis</code>. See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-weight\" target=\"_blank\">scatter-weight</a> for example.</p>\n</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p>You may also set the type of mark line through <code class=\"codespan\">type</code>, stating whether it is for the maximum value or average value. Likewise, dimensions can be assigned through <code class=\"codespan\">valueIndex</code>.</p>\n<pre><code>data: [\n\n{\n        name: &#39;average line&#39;,\n        // &#39;average&#39;, &#39;min&#39;, and &#39;max&#39; are supported\n        type: &#39;average&#39;\n    },\n    {\n        name: &#39;Horizontal line with Y value at 100&#39;,\n        yAxis: 100\n    },\n    [\n        {\n            // Use the same name with starting and ending point\n            name: &#39;Minimum to Maximum&#39;,\n            type: &#39;min&#39;\n        },\n        {\n            type: &#39;max&#39;\n        }\n    ],\n[\n        {\n            name: &#39;Markline between two points&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [{\n        // Mark line with a fixed X position in starting point. This is used to generate an arrow pointing to maximum line.\n        yAxis: &#39;max&#39;,\n        x: &#39;90%&#39;\n    }, {\n        type: &#39;max&#39;\n    }],\n[\n        {\n            name: &#39;Mark line between two points&#39;,\n            x: 100,\n            y: 100\n        },\n        {\n            x: 500,\n            y: 200\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Data of the starting point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n<li><code class=\"codespan\">&#39;median&#39;</code> median value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-candlestick.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-candlestick.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'starting point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of starting point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>starting point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of starting point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of starting point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Data of the ending point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n<li><code class=\"codespan\">&#39;median&#39;</code> median value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-candlestick.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-candlestick.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'ending point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of ending point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>ending point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of ending point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of ending point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markArea":{"type":["Object"],"description":"<p>Used to mark an area in chart. For example, mark a time interval.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label in mark area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Style of the mark area.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark area.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>The scope of the area is defined by <code class=\"codespan\">data</code>, which is an array with two item, representing the left-top point and the right-bottom point of rectangle area. Each item can be defined as follows:</p>\n<ol>\n<li>Specify the coordinate in screen coordinate system using <a href=\"#series-candlestick.markArea.data.0.x\">x</a>, <a href=\"#series-candlestick.markArea.data.0.y\">y</a>, where the unit is pixel (e.g., the value is <code class=\"codespan\">5</code>), or percent (e.g., the value is <code class=\"codespan\">&#39;35%&#39;</code>).</li>\n</ol>\n<ol start=\"2\">\n<li><p>Specify the coordinate in data coordinate system (i.e., cartesian) using\n<a href=\"#series-candlestick.markArea.data.0.coord\">coord</a>, which can be also set as <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> (e.g, <code class=\"codespan\">coord: [23, &#39;min&#39;]</code>, or <code class=\"codespan\">coord: [&#39;average&#39;, &#39;max&#39;]</code>).</p>\n</li>\n<li><p>Locate the point on the min value or max value of <code class=\"codespan\">series.data</code> using <a href=\"#series-candlestick.markArea.data.0.type\">type</a>, where <a href=\"#series-candlestick.markArea.data.0.valueIndex\">valueIndex</a> or <a href=\"#series-candlestick.markPoint.data.0.valueDim\">valueDim</a> can be used to specify the dimension on which the min, max or average are calculated.</p>\n</li>\n<li>If in cartesian, you can only specify <code class=\"codespan\">xAxis</code> or <code class=\"codespan\">yAxis</code> to define a mark area based on only X or Y axis, see sample <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-weight\" target=\"_blank\">scatter-weight</a></li>\n</ol>\n<p>The priority follows as above if more than one above definition used.</p>\n<pre><code>data: [\n\n\n    [\n        {\n            name: &#39;From average to max&#39;,\n            type: &#39;average&#39;\n        },\n        {\n            type: &#39;max&#39;\n        }\n    ],\n\n    [\n        {\n            name: &#39;Mark area between two points in data coordiantes&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [\n        {\n            name: &#39;From 60 to 80&#39;,\n            yAxis: 60\n        },\n        {\n            yAxis: 80\n        }\n    ], [\n        {\n            name: &#39;Mark area covers all data&#39;\n            coord: [&#39;min&#39;, &#39;min&#39;]\n        },\n        {\n            coord: [&#39;max&#39;, &#39;max&#39;]\n        }\n    ],\n[\n        {\n            name: &#39;Mark area in two screen points&#39;,\n            x: 100,\n            y: 100\n        }, {\n            x: &#39;90%&#39;,\n            y: &#39;10%&#39;\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Specify the left-top point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Specify this item is on min or max or average value.</p>\n<p><strong>Options:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> max value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> min value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-candlestick.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-candlestick.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'start'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Specify the right-bottom point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Specify this item is on min or max or average value.</p>\n<p><strong>Options:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> max value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> min value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-candlestick.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-candlestick.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'end'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"false","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"clip":{"type":["boolean"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v4.5.0</code></p>\n</blockquote>\n<p>If clip the overflow on the coordinate system. Clip results varies between series:</p>\n<ul>\n<li>Scatter：Ignore the symbols exceeds the coordinate system. Not clip the elements.</li>\n<li>Bar：Clip all the overflowed. With bar width kept.</li>\n<li>Line：Clip the overflowed line.</li>\n<li>Lines: Clip all the overflowed.</li>\n<li>Candlestick: Ignore the elements exceeds the coordinate system.</li>\n<li>Custom: Clip all the olverflowed.</li>\n</ul>\n<p>All these series have default value <code class=\"codespan\">true</code> except custom series. Set it to <code class=\"codespan\">false</code> if you don&#39;t want to clip.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in Candlestick .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in Candlestick , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"300","step":"20","clean":"true"},"default":300},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"linear"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p><strong>heat map</strong></p>\n<p>Heat map mainly use colors to represent values, which must be used along with <a href=\"#visualMap\">visualMap</a> component.</p>\n<p>It can be used in either <a href=\"#grid\">rectangular coordinate</a> or <a href=\"#geo\">geographic coordinate</a>. But the behaviour on them are quite different. Rectangular coordinate must have two catagories to use it.</p>\n<p>Here are the examples using it in rectangular coordinate and geographic coordinate:</p>\n<p><strong>rectangular coordinate: </strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=heatmap-cartesian&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n","properties":{"type":{"type":["string"],"description":"","default":"'heatmap'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"coordinateSystem":{"type":["string"],"description":"<p>The coordinate used in the series, whose options are:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;cartesian2d&#39;</code></p>\n<p>  Use a two-dimensional rectangular coordinate (also known as Cartesian coordinate), with <a href=\"#series-heatmap.xAxisIndex\">xAxisIndex</a> and <a href=\"#series-heatmap.yAxisIndex\">yAxisIndex</a> to assign the corresponding axis component.</p>\n</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;geo&#39;</code></p>\n<p>  Use geographic coordinate, with <a href=\"#series-heatmap.geoIndex\">geoIndex</a> to assign the corresponding geographic coordinate components.</p>\n</li>\n</ul>\n","default":"'cartesian2d'"},"xAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#xAxis\">x axis</a> to combine with, which is  useful for multiple x axes in one chart.</p>\n","default":0},"yAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#yAxis\">y axis</a> to combine with, which is  useful for multiple y axes in one chart.</p>\n","default":0},"geoIndex":{"type":["number"],"description":"<p>Index of <a href=\"#geo\">geographic coordinate</a> to combine with, which is useful for multiple geographic axes in one chart.</p>\n","default":0},"calendarIndex":{"type":["number"],"description":"<p>Index of <a href=\"#calendar\">calendar coordinates</a> to combine with, which is useful for multiple calendar coordinates in one chart.</p>\n","default":0},"pointSize":{"type":["number"],"description":"<p>Point size of each data point. It is valid with <a href=\"#series-heatmap.coordinateSystem\">coordinateSystem</a> of &#39;geo&#39; value.</p>\n","default":20},"blurSize":{"type":["number"],"description":"<p>Blur size of each data point. It is valid with <a href=\"#series-heatmap.coordinateSystem\">coordinateSystem</a> of &#39;geo&#39; value.</p>\n","default":20},"minOpacity":{"type":["number"],"description":"<p>Minimum opacity. It is valid with <a href=\"#series-heatmap.coordinateSystem\">coordinateSystem</a> of &#39;geo&#39; value.</p>\n","default":0},"maxOpacity":{"type":["number"],"description":"<p>Maximum opacity. It is valid with <a href=\"#series-heatmap.coordinateSystem\">coordinateSystem</a> of &#39;geo&#39; value.</p>\n","default":1},"progressive":{"type":["number"],"description":"<p><code class=\"codespan\">progressive</code> specifies the amount of graphic elements that can be rendered within a frame (about 16ms) if &quot;progressive rendering&quot; enabled.</p>\n<p>When data amount is from thousand to more than 10 million, it will take too long time to render all of the graphic elements. Since ECharts 4, &quot;progressive rendering&quot; is supported in its workflow, which processes and renders data chunk by chunk alone with each frame, avoiding to block the UI thread of the browser.</p>\n<p>Set <code class=\"codespan\">progressive: 0</code> to disable progressive permanently. By default, progressive is auto-enabled when data amount is bigger than <code class=\"codespan\">progressiveThreshold</code>.</p>\n","default":400},"progressiveThreshold":{"type":["number"],"description":"<p>If current data amount is over the threshold, &quot;progressive rendering&quot; is enabled.</p>\n","default":3000},"label":{"type":["Object"],"description":"<p>Work for <a href=\"#series-heatmap.coordinateSystem\">coordinateSystem</a>: &#39;cartesian2d&#39;.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"inside"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"itemStyle":{"type":["Object"],"description":"<p>Work for <a href=\"#series-heatmap.coordinateSystem\">coordinateSystem</a>: &#39;cartesian2d&#39;.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"inside"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Available when <a href=\"#series-heatmap.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"inside"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of select state. Available when <a href=\"#series-heatmap.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"inside"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"data":{"type":["Array"],"description":"<p>Data array of series, which can be in the following forms:</p>\n<p>Notice, if no <code class=\"codespan\">data</code> specified in series, and there is <a href=\"#dataset\">dataset</a> in option, series will use the first <a href=\"#dataset\">dataset</a> as its datasource. If <code class=\"codespan\">data</code> has been specified, <a href=\"#dataset\">dataset</a> will not used.</p>\n<p><code class=\"codespan\">series.datasetIndex</code> can be used to specify other <a href=\"#dataset\">dataset</a>.</p>\n<p>Basically, data is represented by a two-dimension array, like the example below, where each column is named as a &quot;dimension&quot;.</p>\n<pre><code class=\"lang-js\">series: [{\n    data: [\n        // dimX   dimY   other dimensions ...\n        [  3.4,    4.5,   15,   43],\n        [  4.2,    2.3,   20,   91],\n        [  10.8,   9.5,   30,   18],\n        [  7.2,    8.8,   18,   57]\n    ]\n}]\n</code></pre>\n<ul>\n<li>In <a href=\"#grid\">cartesian (grid)</a>, &quot;dimX&quot; and &quot;dimY&quot; correspond to <a href=\"#xAxis\">xAxis</a> and <a href=\"#yAxis\">yAxis</a> respectively.</li>\n<li>In <a href=\"#polar\">polar</a> &quot;dimX&quot; and &quot;dimY&quot; correspond to <a href=\"#radiusAxis\">radiusAxis</a> 和 <a href=\"#anbleAxis\">angleAxis</a> respectively.</li>\n<li>Other dimensions are optional, which can be used in other places. For example:<ul>\n<li><a href=\"#visualMap\">visualMap</a> can map one or more dimensions to visual (color, symbol size ...).</li>\n<li><a href=\"#series.symbolSize\">series.symbolSize</a> can be set as a callback function, where symbol size can be calculated by values of a certain dimension.</li>\n<li>Values in other dimensions can be shown by <a href=\"#tooltip.formatter\">tooltip.formatter</a> or <a href=\"#series.label.formatter\">series.label.formatter</a>.</li>\n</ul>\n</li>\n</ul>\n<p>Especially, when there is one and only one category axis (axis.type is <code class=\"codespan\">&#39;category&#39;</code>), data can be simply be represented by a one-dimension array, like:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    data: [&#39;a&#39;, &#39;b&#39;, &#39;m&#39;, &#39;n&#39;]\n},\nseries: [{\n    // Each item corresponds to each item in xAxis.data.\n    data: [23,  44,  55,  19]\n    // In fact, it is the simplification of the format below:\n    // data: [[0, 23], [1, 44], [2, 55], [3, 19]]\n}]\n</code></pre>\n<p><br>\n<strong>Relationship between &quot;value&quot; and <a href=\"#xAxis.type\">axis.type</a></strong></p>\n<ul>\n<li><p>When a dimension corresponds to a value axis (axis.type is <code class=\"codespan\">&#39;value&#39;</code> or <code class=\"codespan\">&#39;log&#39;</code>):</p>\n<p>  The value can be a <code class=\"codespan\">number</code> (like <code class=\"codespan\">12</code>) (can also be a number in a <code class=\"codespan\">string</code> format, like <code class=\"codespan\">&#39;12&#39;</code>).</p>\n</li>\n<li><p>When a dimension corresponds to a category axis (axis.type is <code class=\"codespan\">&#39;category&#39;</code>):</p>\n<p>  The value should be the ordinal of the axis.data (based on <code class=\"codespan\">0</code>), the string value of the axis.data. For example:</p>\n<pre><code class=\"lang-js\">  xAxis: {\n      type: &#39;category&#39;,\n      data: [&#39;Monday&#39;, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;]\n  },\n  yAxis: {\n      type: &#39;category&#39;,\n      data: [&#39;a&#39;, &#39;b&#39;, &#39;m&#39;, &#39;n&#39;, &#39;p&#39;, &#39;q&#39;]\n  },\n  series: [{\n      data: [\n          // xAxis      yAxis\n          [  0,           0,    2  ], // This point is located at xAxis: &#39;Monday&#39;, yAxis: &#39;a&#39;.\n          [  &#39;Thursday&#39;,  2,    1  ], // This point is located at xAxis: &#39;Thursday&#39;, yAxis: &#39;m&#39;.\n          [  2,          &#39;p&#39;,   2  ], // This point is located at xAxis: &#39;Wednesday&#39;, yAxis: &#39;p&#39;.\n          [  3,           3,    5  ]\n      ]\n  }]\n</code></pre>\n<p>  There is an example of double category axes: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-punchCard\" target=\"_blank\">Github Punchcard</a>.</p>\n</li>\n<li><p>When a dimension corresponds to a time axis (type is <code class=\"codespan\">&#39;time&#39;</code>), the value can be:</p>\n<ul>\n<li>a timestamp, like <code class=\"codespan\">1484141700832</code>, which represents a UTC time.</li>\n<li>a date string, in one of the formats below:<ul>\n<li>a subset of <a href=\"http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15\" target=\"_blank\">ISO 8601</a>, only including (all of these are treated as local time unless timezone is specified, which is consistent with <a href=\"https://momentjs.com/\" target=\"_blank\">moment</a>):<ul>\n<li>only part of year/month/date/time are specified: <code class=\"codespan\">&#39;2012-03&#39;</code>, <code class=\"codespan\">&#39;2012-03-01&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 05&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 05:06&#39;</code>.</li>\n<li>separated by <code class=\"codespan\">&quot;T&quot;</code> or a space: <code class=\"codespan\">&#39;2012-03-01T12:22:33.123&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 12:22:33.123&#39;</code>.</li>\n<li>timezone specified: <code class=\"codespan\">&#39;2012-03-01T12:22:33Z&#39;</code>, <code class=\"codespan\">&#39;2012-03-01T12:22:33+8000&#39;</code>, <code class=\"codespan\">&#39;2012-03-01T12:22:33-05:00&#39;</code>.</li>\n</ul>\n</li>\n<li>other date string format (all of these are treated as local time):\n<code class=\"codespan\">&#39;2012&#39;</code>, <code class=\"codespan\">&#39;2012-3-1&#39;</code>, <code class=\"codespan\">&#39;2012/3/1&#39;</code>, <code class=\"codespan\">&#39;2012/03/01&#39;</code>,\n<code class=\"codespan\">&#39;2009/6/12 2:00&#39;</code>, <code class=\"codespan\">&#39;2009/6/12 2:05:08&#39;</code>, <code class=\"codespan\">&#39;2009/6/12 2:05:08.123&#39;</code>.</li>\n</ul>\n</li>\n<li>a JavaScript Date instance created by user:<ul>\n<li>Caution, when using a data string to create a Date instance, <a href=\"http://dygraphs.com/date-formats.html\" target=\"_blank\">browser differences and inconsistencies</a> should be considered.</li>\n<li>For example: In chrome, <code class=\"codespan\">new Date(&#39;2012-01-01&#39;)</code> is treated as a Jan 1st 2012 in UTC, while <code class=\"codespan\">new Date(&#39;2012-1-1&#39;)</code> and <code class=\"codespan\">new Date(&#39;2012/01/01&#39;)</code> are treated as Jan 1st 2012 in local timezone. In safari <code class=\"codespan\">new Date(&#39;2012-1-1&#39;)</code> is not supported.</li>\n<li>So if you intent to perform <code class=\"codespan\">new Date(dateString)</code>, it is strongly recommended to use a time parse library (e.g., <a href=\"https://momentjs.com/\" target=\"_blank\">moment</a>), or use <code class=\"codespan\">echarts.number.parseDate</code>, or check <a href=\"http://dygraphs.com/date-formats.html\" target=\"_blank\">this</a>.</li>\n</ul>\n</li>\n</ul>\n</li>\n</ul>\n<p><br>\n<strong>Customize a data item:</strong></p>\n<p>When needing to customize a data item, it can be set as an object, where property <code class=\"codespan\">value</code> reprensent real value. For example:</p>\n<pre><code class=\"lang-js\">[\n    12,\n    24,\n    {\n        value: [24, 32],\n        // label style, only works in this data item.\n        label: {},\n        // item style, only works in this data item.\n        itemStyle:{}\n    },\n    33\n]\n// Or\n[\n    [12, 332],\n    [24, 32],\n    {\n        value: [24, 32],\n        // label style, only works in this data item.\n        label: {},\n        // item style, only works in this data item.\n        itemStyle:{}\n    },\n    [33, 31]\n]\n</code></pre>\n<p><br>\n<strong>Empty value:</strong></p>\n<p><code class=\"codespan\">&#39;-&#39;</code> or <code class=\"codespan\">null</code> or <code class=\"codespan\">undefined</code> or <code class=\"codespan\">NaN</code> can be used to describe that a data item does not exist (ps：<em>not exist</em> does not means its value is <code class=\"codespan\">0</code>).</p>\n<p>For example, line chart can break when encounter an empty value, and scatter chart do not display graphic elements for empty values.</p>\n<p><br><br></p>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Name of data item.</p>\n"},"value":{"type":["Array"],"description":"<p>Value of data item.</p>\n"},"label":{"type":["Object"],"description":"<p>It is valid with <a href=\"#series-heatmap.coordinateSystem\">coordinateSystem</a> of &#39;cartesian2d&#39; value.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"inside"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Style of a single data point. It is valid with <a href=\"#series-heatmap.coordinateSystem\">coordinateSystem</a> of &#39;cartesian2d&#39; value.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"inside"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}},"markPoint":{"type":["Object"],"description":"<p>Mark point in a chart.</p>\n","properties":{"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-heatmap.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'pin'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-heatmap.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":50},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-heatmap.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label of mark point.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark point.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Data array for mark points, each of which is an object. Here are some ways to assign mark point position.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-heatmap.markPoint.data.x\">x</a>, <a href=\"#series-heatmap.markPoint.data.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p><strong>For example: </strong></p>\n<pre><code class=\"lang-js\">data: [\n\n    {\n        name: &#39;screen coordinate&#39;,\n        x: 100,\n        y: 100\n    }\n]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Mark point name.</p>\n","default":"''"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markLine":{"type":["Object"],"description":"<p>Use a line in the chart to illustrate.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"symbol":{"type":["string","Array"],"description":"<p>Symbol type at the two ends of the mark line. It can be an array for two ends, or assigned seperately. See <a href=\"#series-heatmap.markLine.data.0.symbol\">data.symbol</a> for more format information.</p>\n"},"symbolSize":{"type":["number","Array"],"description":"<p>Symbol size at the two ends of the mark line. It can be an array for two ends, or assigned seperately.</p>\n<p><strong>Attention: </strong> You cannot assgin width and height seperately as normal <code class=\"codespan\">symbolSize</code>.</p>\n"},"precision":{"type":["number"],"description":"<p>Precision of marking line value, which is useful when displaying average value mark line.</p>\n","default":2},"label":{"type":["Object"],"description":"<p>Mark line text.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"<p>Mark line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark line.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>Data array of marking line. Every array item can be an array of one or two values, representing starting and ending point of the line, and every item is an object. Here are several ways to assign the positions of starting and ending point.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-heatmap.markLine.data.0.x\">x</a>, <a href=\"#series-heatmap.markLine.data.0.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<pre><code>data: [\n\n[\n        {\n            name: &#39;Mark line between two points&#39;,\n            x: 100,\n            y: 100\n        },\n        {\n            x: 500,\n            y: 200\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Data of the starting point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'starting point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of starting point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>starting point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of starting point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of starting point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Data of the ending point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'ending point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of ending point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>ending point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of ending point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of ending point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markArea":{"type":["Object"],"description":"<p>Used to mark an area in chart. For example, mark a time interval.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label in mark area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Style of the mark area.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark area.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>The scope of the area is defined by <code class=\"codespan\">data</code>, which is an array with two item, representing the left-top point and the right-bottom point of rectangle area. Each item can be defined as follows:</p>\n<ol>\n<li>Specify the coordinate in screen coordinate system using <a href=\"#series-heatmap.markArea.data.0.x\">x</a>, <a href=\"#series-heatmap.markArea.data.0.y\">y</a>, where the unit is pixel (e.g., the value is <code class=\"codespan\">5</code>), or percent (e.g., the value is <code class=\"codespan\">&#39;35%&#39;</code>).</li>\n</ol>\n<p>The priority follows as above if more than one above definition used.</p>\n<pre><code>data: [\n\n[\n        {\n            name: &#39;Mark area in two screen points&#39;,\n            x: 100,\n            y: 100\n        }, {\n            x: &#39;90%&#39;,\n            y: &#39;10%&#39;\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Specify the left-top point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'start'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Specify the right-bottom point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'end'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"false","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in heatmap.</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in heatmap, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p><strong>Map.</strong></p>\n<p>Map is mainly used in the visualization of geographic area data, which can be used with <a href=\"#visualMap\">visualMap</a> component to visualize the datas such as population distribution density in diffrent areas.</p>\n<p>Series of same <a href=\"#series-map.map\">map type</a> will show in one map. At this point, the configuration of the first series will be used for the map configuration.</p>\n","properties":{"type":{"type":["string"],"description":"","default":"'map'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"map":{"type":["string"],"description":"<p>Map charts.</p>\n<p>Due to the increase of fineness of map, ECharts 3 doesn&#39;t include map data by default for package size consideration. You may find map files you need on <a href=\"http://ecomfe.github.io/echarts-builder-web/map3.html\" target=\"_blank\">map download page</a> and then include and register them in ECharts.</p>\n<p>Two formats of map data are provided in ECharts, one of which can be included in <code class=\"codespan\">&lt;script&gt;</code> tag as JavaScript file, and the other of is in JSON format and should be loaded using AJAX. Map name and data will be loaded automatically once the JavaScript file is loaded, while in the JSON form, you have to assign name explicitly.</p>\n<p>Here are examples of these two types:</p>\n<p><strong> JavaScript importing example </strong></p>\n<pre><code class=\"lang-html\">&lt;script src=&quot;echarts.js&quot;&gt;&lt;/script&gt;\n&lt;script src=&quot;map/js/china.js&quot;&gt;&lt;/script&gt;\n&lt;script&gt;\nvar chart = echarts.init(document.getElmentById(&#39;main&#39;));\nchart.setOption({\n    series: [{\n        type: &#39;map&#39;,\n        map: &#39;china&#39;\n    }]\n});\n&lt;/script&gt;\n</code></pre>\n<p><strong> JSON importing example </strong></p>\n<pre><code class=\"lang-js\">$.get(&#39;map/json/china.json&#39;, function (chinaJson) {\n    echarts.registerMap(&#39;china&#39;, chinaJson);\n    var chart = echarts.init(document.getElmentById(&#39;main&#39;));\n    chart.setOption({\n        series: [{\n            type: &#39;map&#39;,\n            map: &#39;china&#39;\n        }]\n    });\n});\n</code></pre>\n<p>ECharts uses <a href=\"http://geojson.org/\" target=\"_blank\">geoJSON</a> format as map outline. Besides the methods introduced above, you can also get <a href=\"http://geojson.org/\" target=\"_blank\">geoJSON</a> data through in other methods if you like and register it in ECharts. Reference to <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=map-usa\" target=\"_blank\">USA Population Estimates</a> for more information.</p>\n","default":"''"},"roam":{"type":["boolean","string"],"description":"\n\n<p>Whether to enable mouse zooming and translating. <code class=\"codespan\">false</code> by default. If either zooming or translating is wanted, it can be set to <code class=\"codespan\">&#39;scale&#39;</code> or <code class=\"codespan\">&#39;move&#39;</code>. Otherwise, set it to be <code class=\"codespan\">true</code> to enable both.</p>\n","uiControl":{"type":"enum","options":"true,false,scale,move"},"default":false},"center":{"type":["Array"],"description":"<p>Center of current view-port, in longitude and latitude.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">center: [115.97, 29.71]\n</code></pre>\n"},"aspectScale":{"type":["number"],"description":"<p>Used to scale aspect of geo.</p>\n<p>The final aspect is calculated by: <code class=\"codespan\">geoBoundingRect.width / geoBoundingRect.height * aspectScale</code>.</p>\n","default":0.75},"boundingCoords":{"type":["Array"],"description":"<p>Two dimension array. Define coord of left-top, right-bottom in layout box.</p>\n<pre><code class=\"lang-js\">// A complete world map\nmap: &#39;world&#39;,\nleft: 0, top: 0, right: 0, bottom: 0,\nboundingCoords: [\n    // [lng, lat] of left-top corner\n    [-180, 90],\n    // [lng, lat] of right-bottom corner\n    [180, -90]\n],\n</code></pre>\n","default":null},"zoom":{"type":["number"],"description":"<p>Zoom rate of current view-port.</p>\n","default":1},"scaleLimit":{"type":["Object"],"description":"<p>Limit of scaling, with <code class=\"codespan\">min</code> and <code class=\"codespan\">max</code>. <code class=\"codespan\">1</code> by default.</p>\n","properties":{"min":{"type":["number"],"description":"<p>Minimum scaling</p>\n"},"max":{"type":["number"],"description":"<p>Maximum scaling</p>\n"}}},"nameMap":{"type":["Object"],"description":"<p>Name mapping for customized areas. For example:</p>\n<pre><code class=\"lang-js\">{\n    &#39;China&#39; : &#39;中国&#39;\n}\n</code></pre>\n"},"nameProperty":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.8.0</code></p>\n</blockquote>\n<p>customized property key for GeoJSON feature. By default, &#39;name&#39; is used as primary key to identify GeoJSON feature.\nFor example:</p>\n<pre><code class=\"lang-js\">{\n    nameProperty: &#39;NAME&#39;, // key to connect following data point to GeoJSON region {&quot;type&quot;:&quot;Feature&quot;,&quot;id&quot;:&quot;01&quot;,&quot;properties&quot;:{&quot;NAME&quot;:&quot;Alabama&quot;}, &quot;geometry&quot;: { ... }}\n    data:[\n        {name: &#39;Alabama&#39;, value: 4822023},\n        {name: &#39;Alaska&#39;, value: 731449},\n    ]\n}\n</code></pre>\n","default":"'name'"},"selectedMode":{"type":["boolean","string"],"description":"<p>Selected mode decides whether multiple selecting is supported. By default, <code class=\"codespan\">false</code> is used for disabling selection. Its value can also be <code class=\"codespan\">&#39;single&#39;</code> for selecting single area, or <code class=\"codespan\">&#39;multiple&#39;</code> for selecting multiple areas.</p>\n","default":false},"label":{"type":["Object"],"description":"<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of Map Area Border, <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"areaColor":{"type":["Color"],"description":"<p>Area filling color.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","default":"'#eee'"},"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Map area style in highlighted state.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"areaColor":{"type":["Color"],"description":"<p>The color of the map area.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","default":"'#eee'"},"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<p>Map area style in selected state.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"areaColor":{"type":["Color"],"description":"<p>The color of the map area.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","default":"'#eee'"},"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between  component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'auto'"},"top":{"type":["string","number"],"description":"<p>Distance between  component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'auto'"},"right":{"type":["string","number"],"description":"<p>Distance between  component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"bottom":{"type":["string","number"],"description":"<p>Distance between  component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"layoutCenter":{"type":["Array"],"description":"<p><code class=\"codespan\">layoutCenter</code> and <code class=\"codespan\">layoutSize</code> provides layout strategy other than <code class=\"codespan\">left/right/top/bottom/width/height</code>.</p>\n<p>When using <code class=\"codespan\">left/right/top/bottom/width/height</code>, it is hard to put the map inside a box area with a fixed width-height ratio. In this case, <code class=\"codespan\">layoutCenter</code> attribute can be used to define the center position of map, and <code class=\"codespan\">layoutSize</code> can be used to define the size of map. For example:</p>\n<pre><code class=\"lang-js\">layoutCenter: [&#39;30%&#39;, &#39;30%&#39;],\n// If width-height ratio is larger than 1, then width is set to be 100.\n// Otherwise, height is set to be 100.\n// This makes sure that it will not exceed the area of 100x100\nlayoutSize: 100\n</code></pre>\n<p>After setting these two values, <code class=\"codespan\">left/right/top/bottom/width/height</code> becomes invalid.</p>\n","default":null},"layoutSize":{"type":["number","string"],"description":"<p>Size of map, see <code class=\"codespan\">layoutCenter</code> for more information. Percentage relative to screen width, and absolute pixel values are supported.</p>\n"},"geoIndex":{"type":["number"],"description":"<p>In default case, map series create exclusive <code class=\"codespan\">geo</code> component for themselves. But <code class=\"codespan\">geoIndex</code> can be used to specify an outer <a href=\"#geo\">geo component</a>, which can be shared with other series like <a href=\"#series-pie\">pie</a>. Moreover, the region color of the outer <a href=\"#geo\">geo component</a> can be controlled by the map series (via <a href=\"#visualMap\">visualMap</a>).</p>\n<p>When <code class=\"codespan\">geoIndex</code> specified, <a href=\"#series-map.map\">series-map.map</a> other style configurations like <a href=\"#series-map.itemStyle\">series-map.itemStyle</a> will not work, but corresponding configurations in <a href=\"#geo\">geo component</a> will be used.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=geo-map-scatter&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":null},"mapValueCalculation":{"type":["string"],"description":"<p>Value of multiple series with the same <a href=\"#series-map.map\">map type</a> can use this option to get a statistical value.</p>\n<p>Supported statistical methods:</p>\n<ul>\n<li><code class=\"codespan\">&#39;sum&#39;</code></li>\n<li><code class=\"codespan\">&#39;average&#39;</code></li>\n<li><code class=\"codespan\">&#39;max&#39;</code></li>\n<li><code class=\"codespan\">&#39;min&#39;</code></li>\n</ul>\n","default":"'sum'"},"showLegendSymbol":{"type":["boolean"],"description":"<p>Show the symbol in related area (dot of series symbol). Available when <a href=\"#legend\">legend</a> component exists.</p>\n"},"seriesLayoutBy":{"type":["string"],"description":"<p>When <a href=\"#dataset\">dataset</a> is used, <code class=\"codespan\">seriesLayoutBy</code> specifies whether the column or the row of <code class=\"codespan\">dataset</code> is mapped to the series, namely, the series is &quot;layout&quot; on columns or rows. Optional values:</p>\n<ul>\n<li>&#39;column&#39;: by default, the columns of <code class=\"codespan\">dataset</code> are mapped the series. In this case, each column represents a dimension.</li>\n<li>&#39;row&#39;：the rows of <code class=\"codespan\">dataset</code> are mapped to the series. In this case, each row represents a dimension.</li>\n</ul>\n<p>Check this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=dataset-series-layout-by\" target=\"_blank\">example</a>.</p>\n","default":"'column'"},"datasetIndex":{"type":["number"],"description":"<p>If <a href=\"#series.data\">series.data</a> is not specified, and <a href=\"#dataset\">dataset</a> exists, the series will use <code class=\"codespan\">dataset</code>. <code class=\"codespan\">datasetIndex</code> specifies which dataset will be used.</p>\n","default":0},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Data array of map series, which can be a single data value, like:</p>\n<pre><code class=\"lang-js\">[12, 34, 56, 10, 23]\n</code></pre>\n<p>Or, if need extra dimensions for components like <a href=\"#visualMap\">visualMap</a> to map to graphic attributes like color, it can also be in the form of array. For example:</p>\n<pre><code class=\"lang-js\">[[12, 14], [34, 50], [56, 30], [10, 15], [23, 10]]\n</code></pre>\n<p>In this case, we can assgin the second value in each array item to <a href=\"#visualMap\">visualMap</a> component.</p>\n<p>More likely, we need to assign name to each data item, in which case each item should be an object:</p>\n<pre><code class=\"lang-js\">[{\n    // name of date item\n    name: &#39;data1&#39;,\n    // value of date item is 8\n    value: 10\n}, {\n    name: &#39;data2&#39;,\n    value: 20\n}]\n</code></pre>\n<p>Each data item can be further customized:</p>\n<pre><code class=\"lang-js\">[{\n    name: &#39;data1&#39;,\n    value: 10\n}, {\n    // name of data item\n    name: &#39;data2&#39;,\n    value : 56,\n    // user-defined label format that only useful for this data item\n    label: {},\n    // user-defined special itemStyle that only useful for this data item\n    itemStyle:{}\n}]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>The name of the map area where the data belongs to, such as <code class=\"codespan\">&#39;China&#39;</code> or <code class=\"codespan\">&#39;United Kingdom&#39;</code> .</p>\n"},"value":{"type":["number"],"description":"<p>The numerical value of this area.</p>\n"},"selected":{"type":["boolean"],"description":"<p>Whether the are selected.</p>\n","default":false},"itemStyle":{"type":["Object"],"description":"<p>Style of item polygon</p>\n","properties":{"areaColor":{"type":["Color"],"description":"<p>Color of the area.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n"},"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'bottom'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of specified region.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"areaColor":{"type":["Color"],"description":"<p>The color of the map area.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n"},"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}},"select":{"type":["Object"],"description":"<p>Select state of polygon.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"areaColor":{"type":["Color"],"description":"<p>The color of the map area.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n"},"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series data.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}}},"markPoint":{"type":["Object"],"description":"<p>Mark point in a chart.</p>\n","properties":{"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-map.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'pin'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-map.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":50},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-map.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label of mark point.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark point.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Data array for mark points, each of which is an object. Here are some ways to assign mark point position.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-map.markPoint.data.x\">x</a>, <a href=\"#series-map.markPoint.data.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li>Assign coordinate position with <a href=\"#series-map.markPoint.data.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p><strong>For example: </strong></p>\n<pre><code class=\"lang-js\">data: [\n    {\n        name: &#39;coordinate&#39;,\n        coord: [10, 20]\n    }, {\n        name: &#39;fixed x position&#39;,\n        yAxis: 10,\n        x: &#39;90%&#39;\n    }, \n\n    {\n        name: &#39;screen coordinate&#39;,\n        x: 100,\n        y: 100\n    }\n]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Mark point name.</p>\n","default":"''"},"valueIndex":{"type":["number"],"description":"\n\n<p>Available when using <a href=\"#series-map.markPoint.data.type\">type</a> it is used to assign maximum value and minimum value in dimensions, it could be <code class=\"codespan\">0</code> (xAxis, radiusAxis), <code class=\"codespan\">1</code> (yAxis, angleAxis), and use the first value axis dimension by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-map.markPoint.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markLine":{"type":["Object"],"description":"<p>Use a line in the chart to illustrate.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"symbol":{"type":["string","Array"],"description":"<p>Symbol type at the two ends of the mark line. It can be an array for two ends, or assigned seperately. See <a href=\"#series-map.markLine.data.0.symbol\">data.symbol</a> for more format information.</p>\n"},"symbolSize":{"type":["number","Array"],"description":"<p>Symbol size at the two ends of the mark line. It can be an array for two ends, or assigned seperately.</p>\n<p><strong>Attention: </strong> You cannot assgin width and height seperately as normal <code class=\"codespan\">symbolSize</code>.</p>\n"},"precision":{"type":["number"],"description":"<p>Precision of marking line value, which is useful when displaying average value mark line.</p>\n","default":2},"label":{"type":["Object"],"description":"<p>Mark line text.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"<p>Mark line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark line.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>Data array of marking line. Every array item can be an array of one or two values, representing starting and ending point of the line, and every item is an object. Here are several ways to assign the positions of starting and ending point.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-map.markLine.data.0.x\">x</a>, <a href=\"#series-map.markLine.data.0.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li>Assign coordinate position with <a href=\"#series-map.markLine.data.0.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<pre><code>data: [\n\n[\n        {\n            name: &#39;Markline between two points&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [{\n        // Mark line with a fixed X position in starting point. This is used to generate an arrow pointing to maximum line.\n        yAxis: &#39;max&#39;,\n        x: &#39;90%&#39;\n    }, {\n        type: &#39;max&#39;\n    }],\n[\n        {\n            name: &#39;Mark line between two points&#39;,\n            x: 100,\n            y: 100\n        },\n        {\n            x: 500,\n            y: 200\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Data of the starting point.</p>\n","properties":{"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-map.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-map.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'starting point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of starting point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>starting point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of starting point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of starting point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Data of the ending point.</p>\n","properties":{"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-map.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-map.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'ending point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of ending point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>ending point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of ending point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of ending point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markArea":{"type":["Object"],"description":"<p>Used to mark an area in chart. For example, mark a time interval.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label in mark area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Style of the mark area.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark area.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>The scope of the area is defined by <code class=\"codespan\">data</code>, which is an array with two item, representing the left-top point and the right-bottom point of rectangle area. Each item can be defined as follows:</p>\n<ol>\n<li>Specify the coordinate in screen coordinate system using <a href=\"#series-map.markArea.data.0.x\">x</a>, <a href=\"#series-map.markArea.data.0.y\">y</a>, where the unit is pixel (e.g., the value is <code class=\"codespan\">5</code>), or percent (e.g., the value is <code class=\"codespan\">&#39;35%&#39;</code>).</li>\n</ol>\n<ol start=\"2\">\n<li>Specify the coordinate in data coordinate system (i.e., cartesian) using\n<a href=\"#series-map.markArea.data.0.coord\">coord</a>, which can be also set as <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> (e.g, <code class=\"codespan\">coord: [23, &#39;min&#39;]</code>, or <code class=\"codespan\">coord: [&#39;average&#39;, &#39;max&#39;]</code>).</li>\n</ol>\n<p>The priority follows as above if more than one above definition used.</p>\n<pre><code>data: [\n\n\n    [\n        {\n            name: &#39;Mark area between two points in data coordiantes&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [\n        {\n            name: &#39;From 60 to 80&#39;,\n            yAxis: 60\n        },\n        {\n            yAxis: 80\n        }\n    ], [\n        {\n            name: &#39;Mark area covers all data&#39;\n            coord: [&#39;min&#39;, &#39;min&#39;]\n        },\n        {\n            coord: [&#39;max&#39;, &#39;max&#39;]\n        }\n    ],\n[\n        {\n            name: &#39;Mark area in two screen points&#39;,\n            x: 100,\n            y: 100\n        }, {\n            x: &#39;90%&#39;,\n            y: &#39;10%&#39;\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Specify the left-top point.</p>\n","properties":{"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-map.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-map.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'start'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Specify the right-bottom point.</p>\n","properties":{"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-map.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-map.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'end'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"false","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p>The series in parallel coordinate system.</p>\n<p><strong>Introduction about Parallel coordinates</strong></p>\n<p><a href=\"https://en.wikipedia.org/wiki/Parallel_coordinates\" target=\"_blank\">Parallel Coordinates</a> is a common way of visualizing high-dimensional geometry and analyzing multivariate data.</p>\n<p>For example, <a href=\"#series-parallel.data\">series-parallel.data</a> is the following data:</p>\n<pre><code class=\"lang-javascript\">[\n    [1,  55,  9,   56,  0.46,  18,  6,  &#39;good&#39;],\n    [2,  25,  11,  21,  0.65,  34,  9,  &#39;excellent&#39;],\n    [3,  56,  7,   63,  0.3,   14,  5,  &#39;good&#39;],\n    [4,  33,  7,   29,  0.33,  16,  6,  &#39;excellent&#39;],\n    { // Data item can also be an Object, so that perticular settings of its line can be set here.\n        value: [5,  42,  24,  44,  0.76,  40,  16, &#39;excellent&#39;]\n        lineStyle: {...},\n    }\n    ...\n]\n</code></pre>\n<p>In data above, each row is a &quot;data item&quot;, and each column represents a &quot;dimension&quot;. For example, the meanings of columns above are: &quot;data&quot;, &quot;AQI&quot;, &quot;PM2.5&quot;, &quot;PM10&quot;, &quot;carbon monoxide level&quot;, &quot;nitrogen dioxide level&quot;, and &quot;sulfur dioxide level&quot;.</p>\n<p>Parallel coordinates are often used to visualize multi-dimension data shown above. Each axis represents a dimension (namely, a column), and each line represents a data item. Data can be brush-selected on axes. For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/parallel-all&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n\n\n<p><strong>Brief about Configuration</strong></p>\n<p>Basic configuration parallel coordinates is shown as follow:</p>\n<pre><code class=\"lang-javascript\">option = {\n    parallelAxis: [                     // Definitions of axes.\n        {dim: 0, name: schema[0].text}, // Each axis has a &#39;dim&#39; attribute, representing dimension index in data.\n        {dim: 1, name: schema[1].text},\n        {dim: 2, name: schema[2].text},\n        {dim: 3, name: schema[3].text},\n        {dim: 4, name: schema[4].text},\n        {dim: 5, name: schema[5].text},\n        {dim: 6, name: schema[6].text},\n        {dim: 7, name: schema[7].text,\n            type: &#39;category&#39;,           // Also supports category data.\n            data: [&#39;Excellent&#39;, &#39;good&#39;, &#39;light pollution&#39;, &#39;moderate pollution&#39;, &#39;heavy pollution&#39;, &#39;severe pollution&#39;]\n        }\n    ],\n    parallel: {                         // Definition of a parallel coordinate system.\n        left: &#39;5%&#39;,                     // Location of parallel coordinate system.\n        right: &#39;13%&#39;,\n        bottom: &#39;10%&#39;,\n        top: &#39;20%&#39;,\n        parallelAxisDefault: {          // A pattern for axis definition, which can avoid repeating in `parallelAxis`.\n            type: &#39;value&#39;,\n            nameLocation: &#39;end&#39;,\n            nameGap: 20\n        }\n    },\n    series: [                           // Here the three series sharing the same parallel coordinate system.\n        {\n            name: &#39;Beijing&#39;,\n            type: &#39;parallel&#39;,           // The type of this series is &#39;parallel&#39;\n            data: [\n                [1,  55,  9,   56,  0.46,  18,  6,  &#39;good&#39;],\n                [2,  25,  11,  21,  0.65,  34,  9,  &#39;excellent&#39;],\n                ...\n            ]\n        },\n        {\n            name: &#39;Shanghai&#39;,\n            type: &#39;parallel&#39;,\n            data: [\n                [3,  56,  7,   63,  0.3,   14,  5,  &#39;good&#39;],\n                [4,  33,  7,   29,  0.33,  16,  6,  &#39;excellent&#39;],\n                ...\n            ]\n        },\n        {\n            name: &#39;Guangzhou&#39;,\n            type: &#39;parallel&#39;,\n            data: [\n                [4,  33,  7,   29,  0.33,  16,  6,  &#39;excellent&#39;],\n                [5,  42,  24,  44,  0.76,  40,  16, &#39;excellent&#39;],\n                ...\n            ]\n        }\n    ]\n};\n</code></pre>\n<p>Three components are involved here: <a href=\"#parallel\">parallel</a>, <a href=\"#parallelAxis\">parallelAxis</a>, <a href=\"#series-parallel\">series-parallel</a></p>\n<ul>\n<li><p><a href=\"#parallel\">parallel</a></p>\n<p>  This component is the coordinate system. One or more series (like &quot;Beijing&quot;, &quot;Shanghai&quot;, and &quot;Guangzhou&quot; in the above example) can share one coordinate system.</p>\n<p>  Like other coordinate systems, multiple parallel coordinate systems can be created in one echarts instance.</p>\n<p>  Position setting is also carried out here.</p>\n</li>\n<li><p><a href=\"#parallelAxis\">parallelAxis</a></p>\n<p>  This is axis configuration. Multiple axes are needed in parallel coordinates.</p>\n<p>  <a href=\"#parallelAxis.parallelIndex\">parallelAxis.parallelIndex</a> is used to specify which coordinate system this axis belongs to. The first coordinate system is used by default.</p>\n</li>\n<li><p><a href=\"#series-parallel\">series-parallel</a></p>\n<p>  This is the definition of parallel series, which will be drawn on parallel coordinate system.</p>\n<p>  <a href=\"#parallelAxis.parallelIndex\">parallelAxis.parallelIndex</a> is used to specify which coordinate system this axis belongs to. The first coordinate system is used by default.</p>\n</li>\n</ul>\n<p><strong>Notes and Best Practices</strong></p>\n<p>When configuring multiple <a href=\"#parallelAxis\">parallelAxis</a>, there might be some common attributes in each axis configuration. To avoid writing them repeatly, they can be put under <a href=\"#parallel.parallelAxisDefault\">parallel.parallelAxisDefault</a>. Before initializing axis, configurations in <a href=\"#parallel.parallelAxisDefault\">parallel.parallelAxisDefault</a> will be merged into <a href=\"#parallelAxis\">parallelAxis</a> to generate the final axis configuration.</p>\n<p><strong>If data is too large and cause bad performance</strong></p>\n<p>It is suggested to set <a href=\"#series-parallel.lineStyle.width\">series-parallel.lineStyle.width</a> to be <code class=\"codespan\">0.5</code> (or less), which may improve performance significantly.</p>\n<p><strong>Display High-Dimension Data</strong></p>\n<p>When dimension number is extremely large, say, more than 50 dimensions, there will be more than 50 axes, which may hardly display in a page.</p>\n<p>In this case, you may use <a href=\"#parallel.axisExpandable\">parallel.axisExpandable</a> to improve the display. See this example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=map-parallel-prices&edit=1&reset=1\" width=\"600\" height=\"460\"></iframe>\n\n\n\n\n\n\n\n\n\n\n\n","exampleBaseOptions":[{"code":"\nconst dataBJ = [\n    [1,55,9,56,0.46,18,6,\"良\"],\n    [2,25,11,21,0.65,34,9,\"优\"],\n    [3,56,7,63,0.3,14,5,\"良\"],\n    [4,33,7,29,0.33,16,6,\"优\"],\n    [5,42,24,44,0.76,40,16,\"优\"],\n    [6,82,58,90,1.77,68,33,\"良\"],\n    [7,74,49,77,1.46,48,27,\"良\"],\n    [8,78,55,80,1.29,59,29,\"良\"],\n    [9,267,216,280,4.8,108,64,\"重度污染\"],\n    [10,185,127,216,2.52,61,27,\"中度污染\"],\n    [11,39,19,38,0.57,31,15,\"优\"],\n    [12,41,11,40,0.43,21,7,\"优\"],\n    [13,64,38,74,1.04,46,22,\"良\"],\n    [14,108,79,120,1.7,75,41,\"轻度污染\"],\n    [15,108,63,116,1.48,44,26,\"轻度污染\"],\n    [16,33,6,29,0.34,13,5,\"优\"],\n    [17,94,66,110,1.54,62,31,\"良\"],\n    [18,186,142,192,3.88,93,79,\"中度污染\"],\n    [19,57,31,54,0.96,32,14,\"良\"],\n    [20,22,8,17,0.48,23,10,\"优\"],\n    [21,39,15,36,0.61,29,13,\"优\"],\n    [22,94,69,114,2.08,73,39,\"良\"],\n    [23,99,73,110,2.43,76,48,\"良\"],\n    [24,31,12,30,0.5,32,16,\"优\"],\n    [25,42,27,43,1,53,22,\"优\"],\n    [26,154,117,157,3.05,92,58,\"中度污染\"],\n    [27,234,185,230,4.09,123,69,\"重度污染\"],\n    [28,160,120,186,2.77,91,50,\"中度污染\"],\n    [29,134,96,165,2.76,83,41,\"轻度污染\"],\n    [30,52,24,60,1.03,50,21,\"良\"],\n    [31,46,5,49,0.28,10,6,\"优\"]\n];\n\nconst dataGZ = [\n    [1,26,37,27,1.163,27,13,\"优\"],\n    [2,85,62,71,1.195,60,8,\"良\"],\n    [3,78,38,74,1.363,37,7,\"良\"],\n    [4,21,21,36,0.634,40,9,\"优\"],\n    [5,41,42,46,0.915,81,13,\"优\"],\n    [6,56,52,69,1.067,92,16,\"良\"],\n    [7,64,30,28,0.924,51,2,\"良\"],\n    [8,55,48,74,1.236,75,26,\"良\"],\n    [9,76,85,113,1.237,114,27,\"良\"],\n    [10,91,81,104,1.041,56,40,\"良\"],\n    [11,84,39,60,0.964,25,11,\"良\"],\n    [12,64,51,101,0.862,58,23,\"良\"],\n    [13,70,69,120,1.198,65,36,\"良\"],\n    [14,77,105,178,2.549,64,16,\"良\"],\n    [15,109,68,87,0.996,74,29,\"轻度污染\"],\n    [16,73,68,97,0.905,51,34,\"良\"],\n    [17,54,27,47,0.592,53,12,\"良\"],\n    [18,51,61,97,0.811,65,19,\"良\"],\n    [19,91,71,121,1.374,43,18,\"良\"],\n    [20,73,102,182,2.787,44,19,\"良\"],\n    [21,73,50,76,0.717,31,20,\"良\"],\n    [22,84,94,140,2.238,68,18,\"良\"],\n    [23,93,77,104,1.165,53,7,\"良\"],\n    [24,99,130,227,3.97,55,15,\"良\"],\n    [25,146,84,139,1.094,40,17,\"轻度污染\"],\n    [26,113,108,137,1.481,48,15,\"轻度污染\"],\n    [27,81,48,62,1.619,26,3,\"良\"],\n    [28,56,48,68,1.336,37,9,\"良\"],\n    [29,82,92,174,3.29,0,13,\"良\"],\n    [30,106,116,188,3.628,101,16,\"轻度污染\"],\n    [31,118,50,0,1.383,76,11,\"轻度污染\"]\n];\n\nconst dataSH = [\n    [1,91,45,125,0.82,34,23,\"良\"],\n    [2,65,27,78,0.86,45,29,\"良\"],\n    [3,83,60,84,1.09,73,27,\"良\"],\n    [4,109,81,121,1.28,68,51,\"轻度污染\"],\n    [5,106,77,114,1.07,55,51,\"轻度污染\"],\n    [6,109,81,121,1.28,68,51,\"轻度污染\"],\n    [7,106,77,114,1.07,55,51,\"轻度污染\"],\n    [8,89,65,78,0.86,51,26,\"良\"],\n    [9,53,33,47,0.64,50,17,\"良\"],\n    [10,80,55,80,1.01,75,24,\"良\"],\n    [11,117,81,124,1.03,45,24,\"轻度污染\"],\n    [12,99,71,142,1.1,62,42,\"良\"],\n    [13,95,69,130,1.28,74,50,\"良\"],\n    [14,116,87,131,1.47,84,40,\"轻度污染\"],\n    [15,108,80,121,1.3,85,37,\"轻度污染\"],\n    [16,134,83,167,1.16,57,43,\"轻度污染\"],\n    [17,79,43,107,1.05,59,37,\"良\"],\n    [18,71,46,89,0.86,64,25,\"良\"],\n    [19,97,71,113,1.17,88,31,\"良\"],\n    [20,84,57,91,0.85,55,31,\"良\"],\n    [21,87,63,101,0.9,56,41,\"良\"],\n    [22,104,77,119,1.09,73,48,\"轻度污染\"],\n    [23,87,62,100,1,72,28,\"良\"],\n    [24,168,128,172,1.49,97,56,\"中度污染\"],\n    [25,65,45,51,0.74,39,17,\"良\"],\n    [26,39,24,38,0.61,47,17,\"优\"],\n    [27,39,24,39,0.59,50,19,\"优\"],\n    [28,93,68,96,1.05,79,29,\"良\"],\n    [29,188,143,197,1.66,99,51,\"中度污染\"],\n    [30,174,131,174,1.55,108,50,\"中度污染\"],\n    [31,187,143,201,1.39,89,53,\"中度污染\"]\n];\n\nconst schema = [\n    {name: 'date', index: 0, text: '日期'},\n    {name: 'AQIindex', index: 1, text: 'AQI'},\n    {name: 'PM25', index: 2, text: 'PM2.5'},\n    {name: 'PM10', index: 3, text: 'PM10'},\n    {name: 'CO', index: 4, text: ' CO'},\n    {name: 'NO2', index: 5, text: 'NO2'},\n    {name: 'SO2', index: 6, text: 'SO2'},\n    {name: '等级', index: 7, text: '等级'}\n];\n\nconst option = {\n    color: [\n        '#c23531', '#91c7ae', '#dd8668'\n    ],\n    legend: {\n        top: 10,\n        data: ['北京', '上海', '广州'],\n        itemGap: 20\n    },\n    parallelAxis: [\n        {dim: 0, name: schema[0].text, inverse: true, max: 31, nameLocation: 'start'},\n        {dim: 1, name: schema[1].text},\n        {dim: 2, name: schema[2].text},\n        {dim: 3, name: schema[3].text},\n        {dim: 4, name: schema[4].text},\n        {dim: 5, name: schema[5].text},\n        {dim: 6, name: schema[6].text},\n        {dim: 7, name: schema[7].text,\n        type: 'category', data: ['优', '良', '轻度污染', '中度污染', '重度污染', '严重污染']}\n    ],\n    parallel: {\n        left: '5%',\n        right: '13%',\n        bottom: '10%',\n        top: '20%',\n        parallelAxisDefault: {\n            type: 'value',\n            name: 'AQI指数',\n            nameLocation: 'end',\n            nameGap: 20,\n            nameTextStyle: {\n                fontSize: 12\n            }\n        }\n    },\n    series: [\n        {\n            name: '北京',\n            type: 'parallel',\n            data: dataBJ\n        },\n        {\n            name: '上海',\n            type: 'parallel',\n            data: dataSH\n        },\n        {\n            name: '广州',\n            type: 'parallel',\n            data: dataGZ\n        }\n    ]\n};\n","name":"parallel-series","title":"平行坐标","title-en":"Parallel"}],"properties":{"type":{"type":["string"],"description":"","default":"'parallel'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"coordinateSystem":{"type":["string"],"description":"<p>The coordinate used in the series, whose options are:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;parallel&#39;</code></p>\n<p>  Use parallel coordinates, with <a href=\"#series-parallel.parallelIndex\">parallelIndex</a> to assign the corresponding parallel coordinate components.</p>\n</li>\n</ul>\n","default":"'parallel'"},"parallelIndex":{"type":["number"],"description":"<p>Index of <a href=\"#parallel\">parallel coordinates</a> to combine with, which is useful for multiple parallel axes in one chart.</p>\n","default":0},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"lineStyle":{"type":["Object"],"description":"<p>Line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"2","min":"0","step":"0.5"},"default":2},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"0.45","min":"0","max":"1","step":"0.01"},"default":0.45}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"2","min":"0","step":"0.5"},"default":2},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"0.45","min":"0","max":"1","step":"0.01"},"default":0.45}}}}},"inactiveOpacity":{"type":["number"],"description":"\n\n<p>When perform brush selection, the unselected lines will be set as this transparency rate (which could darken those lines).</p>\n","uiControl":{"type":"number","min":"0","max":"1","default":"0.05","step":"0.01"},"default":0.05},"activeOpacity":{"type":["number"],"description":"\n\n<p>When perform brush selection, the selected lines will be set as this transparency rate (which could highlight those lines).</p>\n","uiControl":{"type":"number","min":"0","max":"1","default":"1","step":"0.01"},"default":1},"realtime":{"type":["boolean"],"description":"\n\n<p>Whether to update view in realtime.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"progressive":{"type":["number"],"description":"<p><code class=\"codespan\">progressive</code> specifies the amount of graphic elements that can be rendered within a frame (about 16ms) if &quot;progressive rendering&quot; enabled.</p>\n<p>When data amount is from thousand to more than 10 million, it will take too long time to render all of the graphic elements. Since ECharts 4, &quot;progressive rendering&quot; is supported in its workflow, which processes and renders data chunk by chunk alone with each frame, avoiding to block the UI thread of the browser.</p>\n<p>Set <code class=\"codespan\">progressive: 0</code> to disable progressive permanently. By default, progressive is auto-enabled when data amount is bigger than <code class=\"codespan\">progressiveThreshold</code>.</p>\n","default":500},"progressiveThreshold":{"type":["number"],"description":"<p>If current data amount is over the threshold, &quot;progressive rendering&quot; is enabled.</p>\n","default":3000},"progressiveChunkMode":{"type":["string"],"description":"<p>Chunk approach, optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;sequential&#39;</code>: slice data by data index.</li>\n<li><code class=\"codespan\">&#39;mod&#39;</code>: slice data by mod, which make the data items of each chunk coming from all over the data, bringing better visual effect while progressive rendering.</li>\n</ul>\n","default":"sequential"},"data":{"type":["Array"],"description":"<p>For example, <a href=\"#series-parallel.data\">series-parallel.data</a> is the following data:</p>\n<pre><code class=\"lang-javascript\">[\n    [1,  55,  9,   56,  0.46,  18,  6,  &#39;good&#39;],\n    [2,  25,  11,  21,  0.65,  34,  9,  &#39;excellent&#39;],\n    [3,  56,  7,   63,  0.3,   14,  5,  &#39;good&#39;],\n    [4,  33,  7,   29,  0.33,  16,  6,  &#39;excellent&#39;],\n    { // Data item can also be an Object, so that perticular settings of its line can be set here.\n        value: [5,  42,  24,  44,  0.76,  40,  16, &#39;excellent&#39;]\n        lineStyle: {...},\n    }\n    ...\n]\n</code></pre>\n<p>In data above, each row is a &quot;data item&quot;, and each column represents a &quot;dimension&quot;. For example, the meanings of columns above are: &quot;data&quot;, &quot;AQI&quot;, &quot;PM2.5&quot;, &quot;PM10&quot;, &quot;carbon monoxide level&quot;, &quot;nitrogen dioxide level&quot;, and &quot;sulfur dioxide level&quot;.</p>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>The name of a data item.</p>\n"},"value":{"type":["Array"],"description":"<p>The value of a data item.</p>\n"},"lineStyle":{"type":["Object"],"description":"<p>Line style.</p>\n"},"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"2","min":"0","step":"0.5"},"default":2},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"0.45","min":"0","max":"1","step":"0.01"},"default":0.45},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"2","min":"0","step":"0.5"},"default":2},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"0.45","min":"0","max":"1","step":"0.01"},"default":0.45}}}}}}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in parallel.</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in parallel, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"linear"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},{"type":["Object"],"description":"<p><strong>Lines graph</strong></p>\n<p>It is used to draw the line data with the information about &quot;from&quot; and &quot;to&quot;; and it is applied fot drawing the air routes on map, which visualizes these routes.</p>\n<p>ECharts 2.x uses the <code class=\"codespan\">markLine</code> to draw the migrating effect, while in ECharts 3, the <code class=\"codespan\">lines</code> graph is recommended to be used.</p>\n","properties":{"type":{"type":["string"],"description":"","default":"'lines'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"coordinateSystem":{"type":["string"],"description":"<p>The coordinate used in the series, whose options are:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;cartesian2d&#39;</code></p>\n<p>  Use a two-dimensional rectangular coordinate (also known as Cartesian coordinate), with <a href=\"#series-lines.xAxisIndex\">xAxisIndex</a> and <a href=\"#series-lines.yAxisIndex\">yAxisIndex</a> to assign the corresponding axis component.</p>\n</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;geo&#39;</code></p>\n<p>  Use geographic coordinate, with <a href=\"#series-lines.geoIndex\">geoIndex</a> to assign the corresponding geographic coordinate components.</p>\n</li>\n</ul>\n","default":"'geo'"},"xAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#xAxis\">x axis</a> to combine with, which is  useful for multiple x axes in one chart.</p>\n","default":0},"yAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#yAxis\">y axis</a> to combine with, which is  useful for multiple y axes in one chart.</p>\n","default":0},"geoIndex":{"type":["number"],"description":"<p>Index of <a href=\"#geo\">geographic coordinate</a> to combine with, which is useful for multiple geographic axes in one chart.</p>\n","default":0},"polyline":{"type":["boolean"],"description":"<p>If draw as a polyline.</p>\n<p>Default to be <code class=\"codespan\">false</code>. Can only draw a two end straight line.</p>\n<p>If it is set true, <a href=\"#series-lines.data.coords\">data.coords</a> can have more than two coord to draw a polyline. It is useful when visualizing GPS track data. See example <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=lines-bmap-bus\" target=\"_blank\">lines-bus</a>.</p>\n","default":false},"effect":{"type":["Object"],"description":"<p>The setting about the special effects of lines.</p>\n<p><strong>Tips: </strong>All the graphs with trail effect should be put on a individual layer, which means that <a href=\"#series-lines.zlevel\">zlevel</a> need to be different with others. And the animation (<a href=\"#series-lines.animation\">animation</a>: false)  of this layer is suggested to be turned off at the meanwhile. Otherwise, other graphic elements in other series and the <a href=\"#series-lines.label\">label</a> of animation would produce unnecessary ghosts.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show special effect.</p>\n","default":false},"period":{"type":["number"],"description":"<p>The duration of special effect, which unit is second.</p>\n","default":4},"delay":{"type":["number","Function"],"description":"<p>Effect animation delay. Can be number or callback function.</p>\n"},"constantSpeed":{"type":["number"],"description":"<p>If symbol movement of special effect has a constant speed, which unit is pixel per second. <a href=\"#series-lines.effect.period\">period</a> will be ignored if <code class=\"codespan\">constantSpeed</code> is larger than 0.</p>\n","default":0},"symbol":{"type":["string"],"description":"<p>The symbol of special effect.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>The above example uses a custom path of plane shape.</p>\n<p><strong>Tip:</strong> Ahe angle of symbol changes as the tangent of track changes. If you use a custom path, you should make sure that the path shape are upward oriented. It would ensure that the symbol will always move toward the right moving direction when the symbol moves along the track.</p>\n","default":"'circle'"},"symbolSize":{"type":["Array","number"],"description":"<p>The symbol size of special effect, which could be set as single number such as <code class=\"codespan\">10</code>. What&#39;s more, arrays could be used to decribe the width and height respectively. For instance, <code class=\"codespan\">[20, 10]</code> indicates <code class=\"codespan\">20</code> for width and  <code class=\"codespan\">10</code> for height.</p>\n","default":3},"color":{"type":["Color"],"description":"<p>The color of special effect symbol, which defaults to be same with <a href=\"#series-lines.lineStyle.color\">lineStyle.color</a>.</p>\n"},"trailLength":{"type":["number"],"description":"<p>The length of trail of special effect.  The values from 0 to 1 could be set. Trail would be longer as the the value becomes larger.</p>\n","default":0.2},"loop":{"type":["boolean"],"description":"<p>Whether to loop the special effect animation.</p>\n","default":true}}},"large":{"type":["boolean"],"description":"<p>Whether to enable the optimization of large-scale lines graph. It could be enabled when there is a particularly large number of data(&gt;=5k) .</p>\n<p>After being enabled, <a href=\"#series-lines.largeThreshold\">largeThreshold</a> can be used to indicate the minimum number for turning on the optimization.</p>\n<p>The style of a single data item can&#39;t be customized</p>\n","default":true},"largeThreshold":{"type":["number"],"description":"<p>The threshold enabling the drawing optimization.</p>\n","default":2000},"symbol":{"type":["string","Array"],"description":"<p>Symbol type at the two ends of the line. It can be an array for two ends, or assigned seperately. See <a href=\"#series-line.markLine.data.0.symbol\">data.symbol</a> for more format information.</p>\n","default":"'none'"},"symbolSize":{"type":["number","Array"],"description":"<p>Symbol size at the two ends of the line. It can be an array for two ends, or assigned seperately.</p>\n<p><strong>Attention: </strong> You cannot assgin width and height seperately as normal <code class=\"codespan\">symbolSize</code>.</p>\n","default":10},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<p>Supports callback functions, in the form of:</p>\n<pre><code class=\"lang-js\">(params: Object) =&gt; Color\n</code></pre>\n<p>Input parameters are <code class=\"codespan\">seriesIndex</code>, <code class=\"codespan\">dataIndex</code>, <code class=\"codespan\">data</code>, <code class=\"codespan\">value</code>, and etc. of data item.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'self-adaptive'"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"0.5","min":"0","max":"1","step":"0.01"},"default":0.5},"curveness":{"type":["number"],"description":"<p>The curveness of edge. The values from 0 to 1 could be set. The curveness would be larger as the the value becomes larger.</p>\n","default":0}}},"label":{"type":["Object"],"description":"<p>Label settings. Does not work when <a href=\"#series-lines.polyline\">polyline</a> is <code class=\"codespan\">true</code>.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show label.</p>\n","default":false},"position":{"type":["string"],"description":"<p>the position of label, options:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","default":"'end'"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show label.</p>\n","default":false},"position":{"type":["string"],"description":"<p>the position of label, options:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","default":"'end'"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Available when <a href=\"#series-lines.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show label.</p>\n","default":false},"position":{"type":["string"],"description":"<p>the position of label, options:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","default":"'end'"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of select state. Available when <a href=\"#series-lines.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show label.</p>\n","default":false},"position":{"type":["string"],"description":"<p>the position of label, options:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","default":"'end'"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"progressive":{"type":["number"],"description":"<p><code class=\"codespan\">progressive</code> specifies the amount of graphic elements that can be rendered within a frame (about 16ms) if &quot;progressive rendering&quot; enabled.</p>\n<p>When data amount is from thousand to more than 10 million, it will take too long time to render all of the graphic elements. Since ECharts 4, &quot;progressive rendering&quot; is supported in its workflow, which processes and renders data chunk by chunk alone with each frame, avoiding to block the UI thread of the browser.</p>\n<p>Set <code class=\"codespan\">progressive: 0</code> to disable progressive permanently. By default, progressive is auto-enabled when data amount is bigger than <code class=\"codespan\">progressiveThreshold</code>.</p>\n","default":400},"progressiveThreshold":{"type":["number"],"description":"<p>If current data amount is over the threshold, &quot;progressive rendering&quot; is enabled.</p>\n","default":3000},"data":{"type":["Array"],"description":"<p>The data set of lines.</p>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>the name of data.</p>\n"},"coords":{"type":["Array"],"description":"<p>An array includes two ore more than two coordinates. Each coordinate could be <code class=\"codespan\">[x, y]</code> in <a href=\"#grid\">rectangular coordinate</a> and <code class=\"codespan\">[lng, lat]</code> in <a href=\"#geo\">geographic coordinate</a>.</p>\n"},"lineStyle":{"type":["Object"],"description":"<p>The line style of this data item.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of a single line. Available when <a href=\"#series-lines.polyline\">polyline</a> is not <code class=\"codespan\">true</code>.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show label.</p>\n","default":false},"position":{"type":["string"],"description":"<p>the position of label, options:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","default":"'end'"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show label.</p>\n","default":false},"position":{"type":["string"],"description":"<p>the position of label, options:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","default":"'end'"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show label.</p>\n","default":false},"position":{"type":["string"],"description":"<p>the position of label, options:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","default":"'end'"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show label.</p>\n","default":false},"position":{"type":["string"],"description":"<p>the position of label, options:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","default":"'end'"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}},"markPoint":{"type":["Object"],"description":"<p>Mark point in a chart.</p>\n","properties":{"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-lines.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'pin'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-lines.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":50},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-lines.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label of mark point.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark point.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Data array for mark points, each of which is an object. Here are some ways to assign mark point position.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-lines.markPoint.data.x\">x</a>, <a href=\"#series-lines.markPoint.data.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p><strong>For example: </strong></p>\n<pre><code class=\"lang-js\">data: [\n\n    {\n        name: &#39;screen coordinate&#39;,\n        x: 100,\n        y: 100\n    }\n]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Mark point name.</p>\n","default":"''"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markLine":{"type":["Object"],"description":"<p>Use a line in the chart to illustrate.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"symbol":{"type":["string","Array"],"description":"<p>Symbol type at the two ends of the mark line. It can be an array for two ends, or assigned seperately. See <a href=\"#series-lines.markLine.data.0.symbol\">data.symbol</a> for more format information.</p>\n"},"symbolSize":{"type":["number","Array"],"description":"<p>Symbol size at the two ends of the mark line. It can be an array for two ends, or assigned seperately.</p>\n<p><strong>Attention: </strong> You cannot assgin width and height seperately as normal <code class=\"codespan\">symbolSize</code>.</p>\n"},"precision":{"type":["number"],"description":"<p>Precision of marking line value, which is useful when displaying average value mark line.</p>\n","default":2},"label":{"type":["Object"],"description":"<p>Mark line text.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"<p>Mark line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark line.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>Data array of marking line. Every array item can be an array of one or two values, representing starting and ending point of the line, and every item is an object. Here are several ways to assign the positions of starting and ending point.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-lines.markLine.data.0.x\">x</a>, <a href=\"#series-lines.markLine.data.0.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<pre><code>data: [\n\n[\n        {\n            name: &#39;Mark line between two points&#39;,\n            x: 100,\n            y: 100\n        },\n        {\n            x: 500,\n            y: 200\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Data of the starting point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'starting point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of starting point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>starting point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of starting point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of starting point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Data of the ending point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'ending point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of ending point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>ending point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of ending point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of ending point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markArea":{"type":["Object"],"description":"<p>Used to mark an area in chart. For example, mark a time interval.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label in mark area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Style of the mark area.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark area.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>The scope of the area is defined by <code class=\"codespan\">data</code>, which is an array with two item, representing the left-top point and the right-bottom point of rectangle area. Each item can be defined as follows:</p>\n<ol>\n<li>Specify the coordinate in screen coordinate system using <a href=\"#series-lines.markArea.data.0.x\">x</a>, <a href=\"#series-lines.markArea.data.0.y\">y</a>, where the unit is pixel (e.g., the value is <code class=\"codespan\">5</code>), or percent (e.g., the value is <code class=\"codespan\">&#39;35%&#39;</code>).</li>\n</ol>\n<p>The priority follows as above if more than one above definition used.</p>\n<pre><code>data: [\n\n[\n        {\n            name: &#39;Mark area in two screen points&#39;,\n            x: 100,\n            y: 100\n        }, {\n            x: &#39;90%&#39;,\n            y: &#39;10%&#39;\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Specify the left-top point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'start'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Specify the right-bottom point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'end'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"false","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"clip":{"type":["boolean"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v4.4.0</code></p>\n</blockquote>\n<p>If clip the overflow on the coordinate system. Clip results varies between series:</p>\n<ul>\n<li>Scatter：Ignore the symbols exceeds the coordinate system. Not clip the elements.</li>\n<li>Bar：Clip all the overflowed. With bar width kept.</li>\n<li>Line：Clip the overflowed line.</li>\n<li>Lines: Clip all the overflowed.</li>\n<li>Candlestick: Ignore the elements exceeds the coordinate system.</li>\n<li>Custom: Clip all the olverflowed.</li>\n</ul>\n<p>All these series have default value <code class=\"codespan\">true</code> except custom series. Set it to <code class=\"codespan\">false</code> if you don&#39;t want to clip.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in 路径图.</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in 路径图, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},{"type":["Object"],"description":"<p><strong>relation graph</strong></p>\n<p>Graph is a diagram to represent <a href=\"#series-graph.nodes\">nodes</a> and the <a href=\"#series-graph.links\">links</a> connecting nodes.</p>\n<p><strong>Example: </strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","properties":{"type":{"type":["string"],"description":"","default":"'graph'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"legendHoverLink":{"type":["boolean"],"description":"\n\n<p>Whether to enable highlighting chart when <a href=\"#legend\">legend</a> is being hovered.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"coordinateSystem":{"type":["string"],"description":"<p>The coordinate used in the series, whose options are:</p>\n<ul>\n<li><p><code class=\"codespan\">null</code> or <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>  No coordinate.</p>\n</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;cartesian2d&#39;</code></p>\n<p>  Use a two-dimensional rectangular coordinate (also known as Cartesian coordinate), with <a href=\"#series-graph.xAxisIndex\">xAxisIndex</a> and <a href=\"#series-graph.yAxisIndex\">yAxisIndex</a> to assign the corresponding axis component.</p>\n</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;polar&#39;</code></p>\n<p>  Use polar coordinates, with <a href=\"#series-graph.polarIndex\">polarIndex</a> to assign the corresponding polar coordinate component.</p>\n</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;geo&#39;</code></p>\n<p>  Use geographic coordinate, with <a href=\"#series-graph.geoIndex\">geoIndex</a> to assign the corresponding geographic coordinate components.</p>\n</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;none&#39;</code></p>\n<p>  Do not use coordinate system.</p>\n</li>\n</ul>\n","default":null},"xAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#xAxis\">x axis</a> to combine with, which is  useful for multiple x axes in one chart.</p>\n","default":0},"yAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#yAxis\">y axis</a> to combine with, which is  useful for multiple y axes in one chart.</p>\n","default":0},"polarIndex":{"type":["number"],"description":"<p>Index of <a href=\"#polar\">polar coordinate</a> to combine with, which is useful for multiple polar axes in one chart.</p>\n","default":0},"geoIndex":{"type":["number"],"description":"<p>Index of <a href=\"#geo\">geographic coordinate</a> to combine with, which is useful for multiple geographic axes in one chart.</p>\n","default":0},"calendarIndex":{"type":["number"],"description":"<p>Index of <a href=\"#calendar\">calendar coordinates</a> to combine with, which is useful for multiple calendar coordinates in one chart.</p>\n","default":0},"center":{"type":["Array"],"description":"\n\n<p>Center of current view-port.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">center: [115.97, 29.71]\n</code></pre>\n","uiControl":{"type":"vector","default":"0,0","dims":"x,y"}},"zoom":{"type":["number"],"description":"\n\n<p>Zoom rate of current view-port.</p>\n","uiControl":{"type":"number","default":"1","min":"0","step":"0.1"},"default":1},"layout":{"type":["string"],"description":"\n\n<p>Graph layout.</p>\n<p><strong>Options: </strong></p>\n<ul>\n<li><p><code class=\"codespan\">&#39;none&#39;</code> No any layout, use  <a href=\"#series-graph.data.x\">x</a>,  <a href=\"#series-graph.data.y\">y</a> provided in <a href=\"#series-graph.data\">node</a> as the position of node.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;circular&#39;</code> Adopt circular layout, see the example <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=graph-circular-layout\" target=\"_blank\">Les Miserables</a>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;force&#39;</code> Adopt force-directed layout, see the example <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=graph-force\" target=\"_blank\">Force</a>, the detail about configrations of layout are in <a href=\"#series-graph.force\">graph.force</a></p>\n</li>\n</ul>\n","uiControl":{"type":"enum","options":"none,force,circular"},"default":"'none'"},"circular":{"type":["Object"],"description":"<p>Configuration about circular layout.</p>\n","properties":{"rotateLabel":{"type":["boolean"],"description":"\n\n<p>Whether to rotate the label automatically.</p>\n","uiControl":{"type":"boolean"},"default":false}}},"force":{"type":["Object"],"description":"<p>Configuration items about force-directed layout. Force-directed layout simulates spring/charge model, which will add a repulsion between 2 nodes and add a attraction between 2 nodes of each edge. In each iteration nodes will move under the effect of repulsion and attraction. After several iterations, the nodes will be static in a balanced position. As a result, the energy local minimum of this whole model will be realized.</p>\n<p>The result of force-directed layout has a good symmetries and clustering, which is also aesthetically pleasing.</p>\n","properties":{"initLayout":{"type":["string"],"description":"<p>The initial layout before force-directed layout, which will influence on the result of force-directed layout.</p>\n<p>It defaults not to do any layout and use <a href=\"#series-graph.data.x\">x</a>, <a href=\"#series-graph.data.y\">y</a> provided in <a href=\"#series-graph.data\">node</a> as the position of node. If it doesn&#39;t exist, the position will be generated randomly.</p>\n<p>You can also use circular layout <code class=\"codespan\">&#39;circular&#39;</code>.</p>\n"},"repulsion":{"type":["Array","number"],"description":"\n\n<p>The repulsion factor between nodes. The repulsion will be stronger and the distance between 2 nodes becomes further as this value becomes larger.</p>\n<p>It can be an array to represent the range of repulsion. In this case larger value have larger repulsion and smaller value will have smaller repulsion.</p>\n","uiControl":{"type":"number","min":"0","step":"5","default":"50"},"default":50},"gravity":{"type":["number"],"description":"\n\n<p>The gravity factor enforcing nodes approach to the center. The nodes will be closer to the center as the value becomes larger.</p>\n","uiControl":{"type":"number","min":"0","step":"0.01","default":"0.1"},"default":0.1},"edgeLength":{"type":["Array","number"],"description":"\n\n<p>The distance between 2 nodes on edge. This distance is also affected by <a href=\"#series-graph.force.repulsion\">repulsion</a>.</p>\n<p>It can be an array to represent the range of edge length. In this case edge with larger value will be shorter, which means two nodes are closer. And edge with smaller value will be longer.</p>\n","uiControl":{"type":"number","min":"0","step":"5","default":"30"},"default":30},"layoutAnimation":{"type":["boolean"],"description":"\n\n<p>Because the force-directed layout will be steady after several iterations, this parameter will be decide whether to show the iteration animation of layout. It is not recommended to be closed on browser when there are a lot of node data (&gt;100) as the layout process will cause browser to hang.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"friction":{"type":["number"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v4.5.0</code></p>\n</blockquote>\n<p>It will slow down the nodes&#39; movement. The value range is from 0 to 1.</p>\n<p>But it is still an experimental option, see <a href=\"https://github.com/apache/echarts/issues/11024\" target=\"_blank\">#11024</a>.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0.6"},"default":0.6}}},"roam":{"type":["boolean","string"],"description":"\n\n<p>Whether to enable mouse zooming and translating. <code class=\"codespan\">false</code> by default. If either zooming or translating is wanted, it can be set to <code class=\"codespan\">&#39;scale&#39;</code> or <code class=\"codespan\">&#39;move&#39;</code>. Otherwise, set it to be <code class=\"codespan\">true</code> to enable both.</p>\n","uiControl":{"type":"enum","options":"true,false,scale,move"},"default":false},"nodeScaleRatio":{"type":["number"],"description":"\n\n<p>Related zooming ratio of nodes when mouse zooming in or out. When it is set as 0, the node will not zoom as the mouse zooms.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0.6"},"default":0.6},"draggable":{"type":["boolean"],"description":"\n\n<p>If node is draggable. Only available when using force-directed layout.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"edgeSymbol":{"type":["Array","string"],"description":"<p>Symbol of two ends of edge line.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">edgeSymbol: [&#39;circle&#39;, &#39;arrow&#39;]\n</code></pre>\n","default":"['none', 'none']"},"edgeSymbolSize":{"type":["Array","number"],"description":"\n\n<p>Size of symbol of two ends of edge line. Can be an array or a single number.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">// Start symbol has size 5 and end symbol has size 10\nsymbolSize: [5, 10],\n// All has size 10\nsymbolSize: 10\n</code></pre>\n","uiControl":{"type":"vector","min":"0","default":"10"},"default":10},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of , <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"color":{"type":["Color","Function"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n<p>Supports callback functions, in the form of:</p>\n<pre><code class=\"lang-js\">(params: Object) =&gt; Color\n</code></pre>\n<p>Input parameters are <code class=\"codespan\">seriesIndex</code>, <code class=\"codespan\">dataIndex</code>, <code class=\"codespan\">data</code>, <code class=\"codespan\">value</code>, and etc. of data item.</p>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"<p>The style of edge line. <a href=\"#series-graph.lineStyle.color\">lineStyle.color</a> can be <code class=\"codespan\">&#39;source&#39;</code> or <code class=\"codespan\">&#39;target&#39;</code>, which will use the color of source node or target node.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#aaa'"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"0.5","min":"0","max":"1","step":"0.01"},"default":0.5},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"edgeLabel":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>If show label on edge.</p>\n","default":false},"position":{"type":["string"],"description":"<p>Label position, options：</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","default":"'middle'"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"emphasis":{"type":["Object"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"scale":{"type":["boolean"],"description":"\n\n<p>Whether to scale to highlight the node in emphasis state.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<ul>\n<li><code class=\"codespan\">&#39;adjacency&#39;</code> Focus on the elements of adjacent nodes and edges in the graph.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"edgeLabel":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>If show label on edge.</p>\n","default":false},"position":{"type":["string"],"description":"<p>Label position, options：</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","default":"'middle'"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Available when <a href=\"#series-graph.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"edgeLabel":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>If show label on edge.</p>\n","default":false},"position":{"type":["string"],"description":"<p>Label position, options：</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","default":"'middle'"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of select state. Available when <a href=\"#series-graph.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"edgeLabel":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>If show label on edge.</p>\n","default":false},"position":{"type":["string"],"description":"<p>Label position, options：</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","default":"'middle'"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"categories":{"type":["Array"],"description":"<p>The categories of node, which is optional.\nIf there is a classification of nodes, the category of each node can be assigned through <a href=\"#series-graph.data.category\">data[i].category</a>. And the style of category will also be applied to the style of nodes. <code class=\"codespan\">categories</code> can also be used in <a href=\"#legend\">legend</a>.</p>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Name of category, which is used to correspond with <a href=\"#legend\">legend</a> and the content of <a href=\"#tooltip\">tooltip</a>.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of node of this category.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>node of this category symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of node of this category symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of node of this category symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"itemStyle":{"type":["Object"],"description":"<p>The style of node in this category.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>The label style of node in this category.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"inside"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of nodes in this category.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state of nodes in this category.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state of nodes in this category.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}},"autoCurveness":{"type":["number","Array"],"description":"<p>For the situation where there are multiple links between nodes, the curveness of each link is automatically calculated.</p>\n<p>When set to <code class=\"codespan\">number</code>, it indicates the length of the edge curvenness array between two nodes, and the calculation result is given by the internal algorithm.</p>\n<p>When set to <code class=\"codespan\">Array</code>, it means that the curveness array is directly specified, and the multilateral curveness is directly selected from the array.</p>\n<p><strong>Notice：</strong> if <a href=\"#series-graph.lineStyle.curveness\">lineStyle.curveness</a> has been set, this property is invalid.</p>\n","default":20},"data":{"type":["Array"],"description":"<p>Nodes list of graph.</p>\n<pre><code class=\"lang-js\">data: [{\n    name: &#39;1&#39;,\n    x: 10,\n    y: 10,\n    value: 10\n}, {\n    name: &#39;2&#39;,\n    x: 100,\n    y: 100,\n    value: 20,\n    symbolSize: 20,\n    itemStyle: {\n        color: &#39;red&#39;\n    }\n}]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Name of data item.</p>\n"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">x</code> value of node position.</p>\n"},"y":{"type":["number"],"description":"<p><code class=\"codespan\">y</code> value of node position.</p>\n"},"fixed":{"type":["boolean"],"description":"<p>If node are fixed when doing force directed layout.</p>\n"},"value":{"type":["number","Array"],"description":"<p>Value of data item.</p>\n"},"category":{"type":["number"],"description":"<p>Index of category which the data item belongs to.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of node of this category.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>node of this category symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of node of this category symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of node of this category symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"itemStyle":{"type":["Object"],"description":"<p>The style of this node.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>The label style of this node.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of specified node.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state of specified node.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state of specified node.</p>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series data.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}}},"nodes":{"type":["Array"],"description":"<p>Alias of <a href=\"#series-graph.data\">data</a></p>\n"},"links":{"type":["Array"],"description":"<p>Relational data between nodes. Example:</p>\n<pre><code class=\"lang-js\">links: [{\n    source: &#39;n1&#39;,\n    target: &#39;n2&#39;\n}, {\n    source: &#39;n2&#39;,\n    target: &#39;n3&#39;\n}]\n</code></pre>\n","items":{"type":"Object","properties":{"source":{"type":["string","number"],"description":"<p>A string representing the <a href=\"#series-graph.data.name\">name of source node</a> on edge. Can also be a number representing the node index.</p>\n"},"target":{"type":["string","number"],"description":"<p>A string representing the <a href=\"#series-graph.data.name\">name of target node</a> on edge. Can also be a number representing node index.</p>\n"},"value":{"type":["number"],"description":"<p>value of edge, can be mapped to edge length in force graph.</p>\n"},"lineStyle":{"type":["Object"],"description":"<p>Line style of edges.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>The curveness of edge, supporting values from 0 to 1. The curveness will be larger as the value becomes lager.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>If show label on edge.</p>\n","default":false},"position":{"type":["string"],"description":"<p>Label position, options：</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;end&#39;</code></li>\n</ul>\n","default":"'middle'"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of specified edge.</p>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state of specified edge.</p>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state of specified edge.</p>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"symbol":{"type":["Array","string"],"description":"<p>Symbol of edge ends. Can be an array with two item to specify two ends, or a string specifies both ends.</p>\n"},"symbolSize":{"type":["Array","string"],"description":"<p>Symbol size of edge ends. Can be an array with two item to specify two ends, or a string specifies both ends.</p>\n"},"ignoreForceLayout":{"type":["boolean"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v4.5.0</code></p>\n</blockquote>\n<p>Prevent this edge from force layout calculating.</p>\n","default":false}}}},"edges":{"type":["Array"],"description":"<p>Alias of <a href=\"#series-graph.links\">links</a></p>\n"},"markPoint":{"type":["Object"],"description":"<p>Mark point in a chart.</p>\n","properties":{"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-graph.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'pin'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-graph.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":50},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-graph.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label of mark point.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark point.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Data array for mark points, each of which is an object. Here are some ways to assign mark point position.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-graph.markPoint.data.x\">x</a>, <a href=\"#series-graph.markPoint.data.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li><p>Assign coordinate position with <a href=\"#series-graph.markPoint.data.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</p>\n</li>\n<li><p>Use <a href=\"#series-graph.markPoint.data.type\">type</a> attribute to mark the maximum and minimum values in the series, in which <a href=\"#series-graph.markPoint.data.valueIndex\">valueIndex</a> or <a href=\"#series-graph.markPoint.data.valueDim\">valueDim</a> can be used to assign the dimension.</p>\n</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p><strong>For example: </strong></p>\n<pre><code class=\"lang-js\">data: [\n    {\n        name: &#39;maximum&#39;,\n        type: &#39;max&#39;\n    }, \n    {\n        name: &#39;coordinate&#39;,\n        coord: [10, 20]\n    }, {\n        name: &#39;fixed x position&#39;,\n        yAxis: 10,\n        x: &#39;90%&#39;\n    }, \n\n    {\n        name: &#39;screen coordinate&#39;,\n        x: 100,\n        y: 100\n    }\n]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Mark point name.</p>\n","default":"''"},"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Available when using <a href=\"#series-graph.markPoint.data.type\">type</a> it is used to assign maximum value and minimum value in dimensions, it could be <code class=\"codespan\">0</code> (xAxis, radiusAxis), <code class=\"codespan\">1</code> (yAxis, angleAxis), and use the first value axis dimension by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-graph.markPoint.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markLine":{"type":["Object"],"description":"<p>Use a line in the chart to illustrate.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"symbol":{"type":["string","Array"],"description":"<p>Symbol type at the two ends of the mark line. It can be an array for two ends, or assigned seperately. See <a href=\"#series-graph.markLine.data.0.symbol\">data.symbol</a> for more format information.</p>\n"},"symbolSize":{"type":["number","Array"],"description":"<p>Symbol size at the two ends of the mark line. It can be an array for two ends, or assigned seperately.</p>\n<p><strong>Attention: </strong> You cannot assgin width and height seperately as normal <code class=\"codespan\">symbolSize</code>.</p>\n"},"precision":{"type":["number"],"description":"<p>Precision of marking line value, which is useful when displaying average value mark line.</p>\n","default":2},"label":{"type":["Object"],"description":"<p>Mark line text.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"<p>Mark line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark line.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>Data array of marking line. Every array item can be an array of one or two values, representing starting and ending point of the line, and every item is an object. Here are several ways to assign the positions of starting and ending point.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-graph.markLine.data.0.x\">x</a>, <a href=\"#series-graph.markLine.data.0.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li><p>Assign coordinate position with <a href=\"#series-graph.markLine.data.0.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</p>\n</li>\n<li><p>Use <a href=\"#series-graph.markLine.data.0.type\">type</a> attribute to mark the maximum and minimum values in the series, in which <a href=\"#series-graph.markLine.data.0.valueIndex\">valueIndex</a> or <a href=\"#series-graph.markLine.data.0.valueDim\">valueDim</a> can be used to assign the dimension.</p>\n</li>\n<li><p>You may also create a mark line in Cartesian coordinate at a specific position in X or Y axis by assigning <code class=\"codespan\">xAxis</code> or <code class=\"codespan\">yAxis</code>. See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-weight\" target=\"_blank\">scatter-weight</a> for example.</p>\n</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p>You may also set the type of mark line through <code class=\"codespan\">type</code>, stating whether it is for the maximum value or average value. Likewise, dimensions can be assigned through <code class=\"codespan\">valueIndex</code>.</p>\n<pre><code>data: [\n\n{\n        name: &#39;average line&#39;,\n        // &#39;average&#39;, &#39;min&#39;, and &#39;max&#39; are supported\n        type: &#39;average&#39;\n    },\n    {\n        name: &#39;Horizontal line with Y value at 100&#39;,\n        yAxis: 100\n    },\n    [\n        {\n            // Use the same name with starting and ending point\n            name: &#39;Minimum to Maximum&#39;,\n            type: &#39;min&#39;\n        },\n        {\n            type: &#39;max&#39;\n        }\n    ],\n[\n        {\n            name: &#39;Markline between two points&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [{\n        // Mark line with a fixed X position in starting point. This is used to generate an arrow pointing to maximum line.\n        yAxis: &#39;max&#39;,\n        x: &#39;90%&#39;\n    }, {\n        type: &#39;max&#39;\n    }],\n[\n        {\n            name: &#39;Mark line between two points&#39;,\n            x: 100,\n            y: 100\n        },\n        {\n            x: 500,\n            y: 200\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Data of the starting point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n<li><code class=\"codespan\">&#39;median&#39;</code> median value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-graph.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-graph.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'starting point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of starting point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>starting point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of starting point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of starting point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Data of the ending point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n<li><code class=\"codespan\">&#39;median&#39;</code> median value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-graph.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-graph.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'ending point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of ending point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>ending point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of ending point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of ending point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markArea":{"type":["Object"],"description":"<p>Used to mark an area in chart. For example, mark a time interval.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label in mark area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Style of the mark area.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark area.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>The scope of the area is defined by <code class=\"codespan\">data</code>, which is an array with two item, representing the left-top point and the right-bottom point of rectangle area. Each item can be defined as follows:</p>\n<ol>\n<li>Specify the coordinate in screen coordinate system using <a href=\"#series-graph.markArea.data.0.x\">x</a>, <a href=\"#series-graph.markArea.data.0.y\">y</a>, where the unit is pixel (e.g., the value is <code class=\"codespan\">5</code>), or percent (e.g., the value is <code class=\"codespan\">&#39;35%&#39;</code>).</li>\n</ol>\n<ol start=\"2\">\n<li><p>Specify the coordinate in data coordinate system (i.e., cartesian) using\n<a href=\"#series-graph.markArea.data.0.coord\">coord</a>, which can be also set as <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> (e.g, <code class=\"codespan\">coord: [23, &#39;min&#39;]</code>, or <code class=\"codespan\">coord: [&#39;average&#39;, &#39;max&#39;]</code>).</p>\n</li>\n<li><p>Locate the point on the min value or max value of <code class=\"codespan\">series.data</code> using <a href=\"#series-graph.markArea.data.0.type\">type</a>, where <a href=\"#series-graph.markArea.data.0.valueIndex\">valueIndex</a> or <a href=\"#series-graph.markPoint.data.0.valueDim\">valueDim</a> can be used to specify the dimension on which the min, max or average are calculated.</p>\n</li>\n<li>If in cartesian, you can only specify <code class=\"codespan\">xAxis</code> or <code class=\"codespan\">yAxis</code> to define a mark area based on only X or Y axis, see sample <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-weight\" target=\"_blank\">scatter-weight</a></li>\n</ol>\n<p>The priority follows as above if more than one above definition used.</p>\n<pre><code>data: [\n\n\n    [\n        {\n            name: &#39;From average to max&#39;,\n            type: &#39;average&#39;\n        },\n        {\n            type: &#39;max&#39;\n        }\n    ],\n\n    [\n        {\n            name: &#39;Mark area between two points in data coordiantes&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [\n        {\n            name: &#39;From 60 to 80&#39;,\n            yAxis: 60\n        },\n        {\n            yAxis: 80\n        }\n    ], [\n        {\n            name: &#39;Mark area covers all data&#39;\n            coord: [&#39;min&#39;, &#39;min&#39;]\n        },\n        {\n            coord: [&#39;max&#39;, &#39;max&#39;]\n        }\n    ],\n[\n        {\n            name: &#39;Mark area in two screen points&#39;,\n            x: 100,\n            y: 100\n        }, {\n            x: &#39;90%&#39;,\n            y: &#39;10%&#39;\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Specify the left-top point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Specify this item is on min or max or average value.</p>\n<p><strong>Options:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> max value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> min value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-graph.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-graph.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'start'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Specify the right-bottom point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Specify this item is on min or max or average value.</p>\n<p><strong>Options:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> max value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> min value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-graph.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-graph.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'end'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"false","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between  component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'center'"},"top":{"type":["string","number"],"description":"<p>Distance between  component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"'middle'"},"right":{"type":["string","number"],"description":"<p>Distance between  component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"bottom":{"type":["string","number"],"description":"<p>Distance between  component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n<p>Adaptive by default.</p>\n","default":"'auto'"},"width":{"type":["string","number"],"description":"<p>Width of  component. </p>\n","default":"auto"},"height":{"type":["string","number"],"description":"<p>Height of  component. </p>\n","default":"auto"},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p><strong> Sankey diagram </strong>\nSankey diagram is a specific type of streamgraph (can also be seen as a directed acyclic graph) in which the width of each branch is shown proportionally to the flow quantity. These graphs are typically used to visualize energy or material or cost transfers between processes. They can also visualize the energy accounts, material flow accounts on a regional or national level, and also the breakdown of cost of item or services.</p>\n<p><strong>Example: </strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=sankey-energy&edit=1&reset=1\" width=\"700\" height=\"580\"></iframe>\n\n\n\n<p><br>\n<strong>Visual Encoding: </strong></p>\n<p>The Sankey diagram encodes each <code class=\"codespan\">node</code> of the raw data into a small rectangle. Different nodes are presented in different colors as far as possible. The <code class=\"codespan\">label</code> next to the small rectangul encodes the name of the node.</p>\n<p>In addition, the edge between two small rectangles in the diagram encodes the <code class=\"codespan\">link</code> of the raw data. The width of edge is shown proportionally to the <code class=\"codespan\">value</code> of <code class=\"codespan\">link</code>.</p>\n","properties":{"type":{"type":["string"],"description":"","default":"'sankey'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between sankey component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"5%"},"top":{"type":["string","number"],"description":"<p>Distance between sankey component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"5%"},"right":{"type":["string","number"],"description":"<p>Distance between sankey component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":"20%"},"bottom":{"type":["string","number"],"description":"<p>Distance between sankey component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":"5%"},"width":{"type":["string","number"],"description":"<p>Width of sankey component. </p>\n","default":null},"height":{"type":["string","number"],"description":"<p>Height of sankey component. </p>\n","default":null},"nodeWidth":{"type":["number"],"description":"\n\n<p>The node width of rectangle in Sankey diagram.</p>\n","uiControl":{"type":"number","default":"20","min":"0","step":"0.5"},"default":20},"nodeGap":{"type":["number"],"description":"\n\n<p>The gap between any two rectangles in each column of the Sankey diagram.</p>\n","uiControl":{"type":"number","default":"8","min":"0","step":"0.5"},"default":8},"nodeAlign":{"type":["string"],"description":"\n\n<p>Controls the horizontal alignment of nodes in the diagram.</p>\n<p>May be:</p>\n<ul>\n<li><p><code class=\"codespan\">left</code>: initial nodes (those with no incoming links) are aligned to the left of the diagram.</p>\n</li>\n<li><p><code class=\"codespan\">right</code>: terminal nodes (those with no outgoing links) are aligned to the right of the diagram.</p>\n</li>\n<li><p><code class=\"codespan\">justify</code>: initial and terminal nodes are aligned on the left and right edges.</p>\n</li>\n</ul>\n<p>Note when <a href=\"#series-sankey.orient\">orient</a> is <code class=\"codespan\">vertical</code>, <code class=\"codespan\">nodeAlign</code> controls vertical alignment.</p>\n","uiControl":{"type":"enum","options":"justify,left,right"},"default":"'justify'"},"layoutIterations":{"type":["number"],"description":"\n\n<p>The iterations of layout, which is used to iteratively optimize the position of the nodes and edges in the Sankey diagram to reduce the overlapping between nodes and edges. The default value is <code class=\"codespan\">32</code>. If you want the order of the nodes in the chart to be the same with the order in the original <a href=\"#series-sankey.data\">data</a>, you can set the value to be <code class=\"codespan\">0</code>.</p>\n","uiControl":{"type":"number","default":"32","min":"0","max":"100","step":"1"},"default":32},"orient":{"type":["string"],"description":"\n\n<p>The layout direction of the nodes in the Sankey diagram, which can be horizontal from left to right or vertical from top to bottom. The corresponding parameter values ​​are <code class=\"codespan\">horizontal</code> or <code class=\"codespan\">vertical</code>.</p>\n","uiControl":{"type":"enum","options":"horizontal,vertical"},"default":"'horizontal'"},"draggable":{"type":["boolean"],"description":"\n\n<p>The drag-and-drop interaction of the node, which is enabled by default. After opening, the user can drag any node in the Sankey diagram to any position. To turn this interaction off, simply set the value to <code class=\"codespan\">false</code>.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"levels":{"type":["Array"],"description":"<p>The setting of each layer of Sankey diagram. Can be set layer by layer, as follows:</p>\n<pre><code class=\"lang-js\">levels: [{\n    depth: 0,\n    itemStyle: {\n        color: &#39;#fbb4ae&#39;\n    },\n    lineStyle: {\n        color: &#39;source&#39;,\n        opacity: 0.6\n    }\n}, {\n    depth: 1,\n    itemStyle: {\n        color: &#39;#b3cde3&#39;\n    },\n    lineStyle: {\n        color: &#39;source&#39;,\n        opacity: 0.6\n    }\n}]\n</code></pre>\n<p>You can also only set a certain layer:</p>\n<pre><code class=\"lang-js\">levels: [{\n    depth: 3,\n    itemStyle: {\n        color: &#39;#fbb4ae&#39;\n    },\n    lineStyle: {\n        color: &#39;source&#39;,\n        opacity: 0.6\n    }\n}]\n</code></pre>\n","items":{"type":"Object","properties":{"depth":{"type":["number"],"description":"\n\n<p>Specify which layer is set, value starts from 0.</p>\n","uiControl":{"type":"number","default":"0","min":"0","step":"1"}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"<p>The color of the edge in Sankey diagram.</p>\n","default":"\"'#314656'\""},"opacity":{"type":["number"],"description":"<p>The opacity of the edge in Sankey diagram.</p>\n","default":0.2},"curveness":{"type":["number"],"description":"\n\n<p>The curveness of the edge in Sankey diagram.</p>\n","uiControl":{"type":"number","min":"0","max":"1","default":"0.5","step":"0.1"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"<p>The color of the edge in Sankey diagram.</p>\n","default":"\"'#314656'\""},"opacity":{"type":["number"],"description":"<p>The opacity of the edge in Sankey diagram.</p>\n","default":0.2},"curveness":{"type":["number"],"description":"\n\n<p>The curveness of the edge in Sankey diagram.</p>\n","uiControl":{"type":"number","min":"0","max":"1","default":"0.5","step":"0.1"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"<p>The color of the edge in Sankey diagram.</p>\n","default":"\"'#314656'\""},"opacity":{"type":["number"],"description":"<p>The opacity of the edge in Sankey diagram.</p>\n","default":0.2},"curveness":{"type":["number"],"description":"\n\n<p>The curveness of the edge in Sankey diagram.</p>\n","uiControl":{"type":"number","min":"0","max":"1","default":"0.5","step":"0.1"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"<p>The color of the edge in Sankey diagram.</p>\n","default":"\"'#314656'\""},"opacity":{"type":["number"],"description":"<p>The opacity of the edge in Sankey diagram.</p>\n","default":0.2},"curveness":{"type":["number"],"description":"\n\n<p>The curveness of the edge in Sankey diagram.</p>\n","uiControl":{"type":"number","min":"0","max":"1","default":"0.5","step":"0.1"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}}}}}}},"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> describes the text label style in each rectangular node.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'right'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"itemStyle":{"type":["Object"],"description":"<p>The style of node rectangle in Sankey diagram.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#aaa'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"lineStyle":{"type":["Object"],"description":"<p>The edge style of Sankey diagram, in which <a href=\"#series-sankey.lineStyle.color\">lineStyle.color</a> can be assigned to the value of <code class=\"codespan\">&#39;source&#39;</code> of <code class=\"codespan\">&#39;target&#39;</code>, then the edge will automatically take the source node or target node color as its own color.</p>\n","properties":{"color":{"type":["Color"],"description":"<p>The color of the edge in Sankey diagram.</p>\n","default":"\"'#314656'\""},"opacity":{"type":["number"],"description":"<p>The opacity of the edge in Sankey diagram.</p>\n","default":0.2},"curveness":{"type":["number"],"description":"\n\n<p>The curveness of the edge in Sankey diagram.</p>\n","uiControl":{"type":"number","min":"0","max":"1","default":"0.5","step":"0.1"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"emphasis":{"type":["Object"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<ul>\n<li><code class=\"codespan\">&#39;ancestor&#39;</code> Focus on all ancestor nodes.</li>\n<li><code class=\"codespan\">&#39;descendant&#39;</code> Focus on all descendants nodes.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"<p>The color of the edge in Sankey diagram.</p>\n","default":"\"'#314656'\""},"opacity":{"type":["number"],"description":"<p>The opacity of the edge in Sankey diagram.</p>\n","default":0.2},"curveness":{"type":["number"],"description":"\n\n<p>The curveness of the edge in Sankey diagram.</p>\n","uiControl":{"type":"number","min":"0","max":"1","default":"0.5","step":"0.1"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Available when <a href=\"#series-sankey.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"<p>The color of the edge in Sankey diagram.</p>\n","default":"\"'#314656'\""},"opacity":{"type":["number"],"description":"<p>The opacity of the edge in Sankey diagram.</p>\n","default":0.2},"curveness":{"type":["number"],"description":"\n\n<p>The curveness of the edge in Sankey diagram.</p>\n","uiControl":{"type":"number","min":"0","max":"1","default":"0.5","step":"0.1"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of selected state. Available when <a href=\"#series-sankey.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"<p>The color of the edge in Sankey diagram.</p>\n","default":"\"'#314656'\""},"opacity":{"type":["number"],"description":"<p>The opacity of the edge in Sankey diagram.</p>\n","default":0.2},"curveness":{"type":["number"],"description":"\n\n<p>The curveness of the edge in Sankey diagram.</p>\n","uiControl":{"type":"number","min":"0","max":"1","default":"0.5","step":"0.1"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"data":{"type":["Array"],"description":"<p>The nodes list of the sankey diagram.</p>\n<pre><code class=\"lang-js\">data: [{\n    name: &#39;node1&#39;,\n    // This attribute decides the layer of the current node.\n    depth: 0\n}, {\n    name: &#39;node2&#39;,\n    depth: 1\n}]\n</code></pre>\n<p><strong>Notice:</strong> The name of the node cannot be repeated.</p>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>The name of the node.</p>\n"},"value":{"type":["number"],"description":"<p>The value of the node, which can used to determine the height of the node in horizontal orient or width in the vertical orient.</p>\n"},"depth":{"type":["number"],"description":"<p>The layer of the node, value starts from 0.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>The style of this node.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"label":{"type":["Object"],"description":"<p>The lable style of this node.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series data.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}}},"nodes":{"type":["Array"],"description":"<p>Equals to <a href=\"#series-sankey.data\">data</a></p>\n"},"links":{"type":["Array"],"description":"<p>The links between nodes. <strong>Notes: The Sankey diagram theoretically only supports Directed Acyclic Graph(DAG), so please make sure that there is no cycle in the links.</strong> For instance:</p>\n<pre><code class=\"lang-js\">links: [{\n    source: &#39;n1&#39;,\n    target: &#39;n2&#39;\n}, {\n    source: &#39;n2&#39;,\n    target: &#39;n3&#39;\n}]\n</code></pre>\n","items":{"type":"Object","properties":{"source":{"type":["string"],"description":"<p>The <a href=\"#series-sankey.data.name\">name of source node</a> of edge</p>\n"},"target":{"type":["string"],"description":"<p>The <a href=\"#series-sankey.data.name\">name of target node</a> of edge</p>\n"},"value":{"type":["number"],"description":"<p>The value of edge, which decides the width of edge.</p>\n"},"lineStyle":{"type":["Object"],"description":"<p>The line stlye of edge.</p>\n","properties":{"color":{"type":["Color"],"description":"<p>The color of the edge in Sankey diagram.</p>\n","default":"\"'#314656'\""},"opacity":{"type":["number"],"description":"<p>The opacity of the edge in Sankey diagram.</p>\n","default":0.2},"curveness":{"type":["number"],"description":"\n\n<p>The curveness of the edge in Sankey diagram.</p>\n","uiControl":{"type":"number","min":"0","max":"1","default":"0.5","step":"0.1"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"<p>The color of the edge in Sankey diagram.</p>\n","default":"\"'#314656'\""},"opacity":{"type":["number"],"description":"<p>The opacity of the edge in Sankey diagram.</p>\n","default":0.2},"curveness":{"type":["number"],"description":"\n\n<p>The curveness of the edge in Sankey diagram.</p>\n","uiControl":{"type":"number","min":"0","max":"1","default":"0.5","step":"0.1"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"<p>The color of the edge in Sankey diagram.</p>\n","default":"\"'#314656'\""},"opacity":{"type":["number"],"description":"<p>The opacity of the edge in Sankey diagram.</p>\n","default":0.2},"curveness":{"type":["number"],"description":"\n\n<p>The curveness of the edge in Sankey diagram.</p>\n","uiControl":{"type":"number","min":"0","max":"1","default":"0.5","step":"0.1"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"<p>The color of the edge in Sankey diagram.</p>\n","default":"\"'#314656'\""},"opacity":{"type":["number"],"description":"<p>The opacity of the edge in Sankey diagram.</p>\n","default":0.2},"curveness":{"type":["number"],"description":"\n\n<p>The curveness of the edge in Sankey diagram.</p>\n","uiControl":{"type":"number","min":"0","max":"1","default":"0.5","step":"0.1"},"default":0.5},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0}}}}}}}},"edges":{"type":["Array"],"description":"<p>Equals to <a href=\"#series-sankey.links\">links</a></p>\n"},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"'linear'"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p><strong>Funnel chart</strong></p>\n<p><strong>sample: </strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=funnel&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","properties":{"type":{"type":["string"],"description":"","default":"'funnel'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"min":{"type":["number"],"description":"\n\n<p>The specified minimum value.</p>\n","uiControl":{"type":"number","default":"0","step":"1"},"default":0},"max":{"type":["number"],"description":"\n\n<p>The specified maximum value.</p>\n","uiControl":{"type":"number","default":"100","step":"1"},"default":100},"minSize":{"type":["number","string"],"description":"\n\n<p>The mapped width from minimum data value <a href=\"#series-funnel.min\">min</a>.</p>\n<p>It can be absolute pixel and also the percentage of <a href=\"#series-funnel.width\">layout width</a>. If you don&#39;t want the graph of minimum value to be a triangle, you can set up this property larger than 0.</p>\n","uiControl":{"type":"percent","default":"0%"},"default":"'0%'"},"maxSize":{"type":["number","string"],"description":"\n\n<p>The mapped width from maximum data value <a href=\"#series-funnel.max\">max</a>.</p>\n<p>It can be absolute pixel and also the percentage of <a href=\"#series-funnel.width\">layout width</a>.</p>\n","uiControl":{"type":"percent","default":"100%"},"default":"'100%'"},"orient":{"type":["string"],"description":"\n\n<p>Orient of funnel，Can be <code class=\"codespan\">&#39;vertical&#39;</code> or <code class=\"codespan\">&#39;horizontal&#39;</code>.</p>\n<blockquote>\n<p>Since <code class=\"codespan\">v4.9.0</code></p>\n</blockquote>\n","uiControl":{"type":"enum","options":"vertical,horizontal"},"default":"'vertical'"},"sort":{"type":["string","Function"],"description":"\n\n<p>Data sorting, which can be whether <code class=\"codespan\">&#39;ascending&#39;</code>, <code class=\"codespan\">&#39;descending&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code>(in data order) or a function, which is the same as <code class=\"codespan\">Array.prototype.sort(function (a, b) { ... })</code>;</p>\n","uiControl":{"type":"enum","options":"none,descending,ascending","default":"descending"},"default":"'descending'"},"gap":{"type":["number"],"description":"\n\n<p>Gap between each trapezoid.</p>\n","uiControl":{"type":"number","default":"0","min":"0","step":"0.5"},"default":0},"legendHoverLink":{"type":["boolean"],"description":"\n\n<p>Whether to enable highlighting chart when <a href=\"#legend\">legend</a> is being hovered.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"funnelAlign":{"type":["string"],"description":"\n\n<p>Horizontal align. Defaults to align center. Can be &#39;left&#39;, &#39;right&#39;, &#39;center&#39;.</p>\n","uiControl":{"type":"enum","options":"left,center,right","default":"center"},"default":"'center'"},"label":{"type":["Object"],"description":"<p>Text label of funnel chart, to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"","default":false},"position":{"type":["string"],"description":"<p>Label position.</p>\n<p><strong>Options: </strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code>Left side of funnel chart. Available when <a href=\"#series-funnel.orient\">orient</a> is <code class=\"codespan\">&#39;vertical&#39;</code>.</li>\n<li><code class=\"codespan\">&#39;right&#39;</code> Right side of funnel chart. Available when <a href=\"#series-funnel.orient\">orient</a> is <code class=\"codespan\">&#39;horizontal&#39;</code>.</li>\n<li><code class=\"codespan\">&#39;top&#39;</code> Top side of funnel chart. Available when <a href=\"#series-funnel.orient\">orient</a> is <code class=\"codespan\">&#39;vertical&#39;</code>.</li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code> Bottom side of funnel chart. Available when <a href=\"#series-funnel.orient\">orient</a> is <code class=\"codespan\">&#39;vertical&#39;</code>.</li>\n<li><code class=\"codespan\">&#39;inside&#39;</code>Inside the trapezoid of funnel chart.</li>\n<li><code class=\"codespan\">&#39;insideRight&#39;</code>Right inside the trapezoid of funnel chart.</li>\n<li><code class=\"codespan\">&#39;insideLeft&#39;</code>Left inside the trapezoid of funnel chart.</li>\n<li><code class=\"codespan\">&#39;leftTop&#39;</code>Top-left of funnel chart.</li>\n<li><code class=\"codespan\">&#39;leftBottom&#39;</code>Bottom-left of funnel chart.</li>\n<li><code class=\"codespan\">&#39;rightTop&#39;</code>Top-right side of funnel chart.</li>\n<li><code class=\"codespan\">&#39;rightBottom&#39;</code>Bottom-right side of funnel chart.</li>\n<li><code class=\"codespan\">&#39;inner&#39;</code> equals to <code class=\"codespan\">&#39;inside&#39;</code>.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code> equals to <code class=\"codespan\">&#39;inside&#39;</code>.</li>\n</ul>\n<p><a href=\"#series-funnel.labelLine\">labelLine</a> can be used to guide to the corresponding trapezoid when label is not inside.</p>\n","default":"'outside'"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // percentage\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>The visual guide line style of label. When <a href=\"#series-funnel.label.position\">label position</a> is set as <code class=\"codespan\">&#39;left&#39;</code>or<code class=\"codespan\">&#39;right&#39;</code>, the visual guide line will show.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show visual guide line.</p>\n"},"length":{"type":["number"],"description":"<p>The length of the first part from visual guide line.</p>\n"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of , <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"color":{"type":["Color","Function"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n<p>Supports callback functions, in the form of:</p>\n<pre><code class=\"lang-js\">(params: Object) =&gt; Color\n</code></pre>\n<p>Input parameters are <code class=\"codespan\">seriesIndex</code>, <code class=\"codespan\">dataIndex</code>, <code class=\"codespan\">data</code>, <code class=\"codespan\">value</code>, and etc. of data item.</p>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"emphasis":{"type":["Object"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"","default":false},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // percentage\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show visual guide line.</p>\n"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Available when <a href=\"#series-funnel.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"","default":false},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // percentage\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show visual guide line.</p>\n"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of select state. Available when <a href=\"#series-funnel.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"","default":false},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // percentage\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show visual guide line.</p>\n"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between Funnel component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":80},"top":{"type":["string","number"],"description":"<p>Distance between Funnel component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":60},"right":{"type":["string","number"],"description":"<p>Distance between Funnel component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":80},"bottom":{"type":["string","number"],"description":"<p>Distance between Funnel component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":60},"width":{"type":["string","number"],"description":"<p>Width of Funnel component. Adaptive by default.</p>\n","default":"'auto'"},"height":{"type":["string","number"],"description":"<p>Height of Funnel component. Adaptive by default.</p>\n","default":"'auto'"},"seriesLayoutBy":{"type":["string"],"description":"<p>When <a href=\"#dataset\">dataset</a> is used, <code class=\"codespan\">seriesLayoutBy</code> specifies whether the column or the row of <code class=\"codespan\">dataset</code> is mapped to the series, namely, the series is &quot;layout&quot; on columns or rows. Optional values:</p>\n<ul>\n<li>&#39;column&#39;: by default, the columns of <code class=\"codespan\">dataset</code> are mapped the series. In this case, each column represents a dimension.</li>\n<li>&#39;row&#39;：the rows of <code class=\"codespan\">dataset</code> are mapped to the series. In this case, each row represents a dimension.</li>\n</ul>\n<p>Check this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=dataset-series-layout-by\" target=\"_blank\">example</a>.</p>\n","default":"'column'"},"datasetIndex":{"type":["number"],"description":"<p>If <a href=\"#series.data\">series.data</a> is not specified, and <a href=\"#dataset\">dataset</a> exists, the series will use <code class=\"codespan\">dataset</code>. <code class=\"codespan\">datasetIndex</code> specifies which dataset will be used.</p>\n","default":0},"dimensions":{"type":["Array"],"description":"<p><code class=\"codespan\">dimensions</code> can be used to define dimension info for <code class=\"codespan\">series.data</code> or <code class=\"codespan\">dataset.source</code>.</p>\n<p>Notice: if <a href=\"#dataset\">dataset</a> is used, we can definite dimensions in <a href=\"#dataset.dimensions\">dataset.dimensions</a>, or provide dimension names in the first column/row of <a href=\"#dataset.source\">dataset.source</a>, and not need to specify <code class=\"codespan\">dimensions</code> here. But if <code class=\"codespan\">dimensions</code> is specified here, it will be used despite the dimension definitions in dataset.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // &#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        // Specify name for each dimesions, which will be displayed in tooltip.\n        dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [\n        null,                // If you do not intent to defined this dimension, use null is fine.\n        {type: &#39;ordinal&#39;},   // Specify type of this dimension.\n                             // &#39;ordinal&#39; is always used in string.\n                             // If type is not specified, echarts will guess type by data.\n        {name: &#39;good&#39;, type: &#39;number&#39;},\n        &#39;bad&#39;                // Equals to {name: &#39;bad&#39;}.\n    ]\n}\n</code></pre>\n<p>Each data item of <code class=\"codespan\">dimensions</code> can be:</p>\n<ul>\n<li><code class=\"codespan\">string</code>, for example, <code class=\"codespan\">&#39;someName&#39;</code>, which equals to <code class=\"codespan\">{name: &#39;someName&#39;}</code>.</li>\n<li><code class=\"codespan\">Object</code>, where the attributes can be:<ul>\n<li>name: <code class=\"codespan\">string</code>.</li>\n<li>type: <code class=\"codespan\">string</code>, supports:<ul>\n<li><code class=\"codespan\">number</code></li>\n<li><code class=\"codespan\">float</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array\" target=\"_blank\">Float64Array</a></li>\n<li><code class=\"codespan\">int</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array\" target=\"_blank\">Int32Array</a></li>\n<li><code class=\"codespan\">ordinal</code>, discrete value, which represents string generally.</li>\n<li><code class=\"codespan\">time</code>, time value, see <a href=\"#series.data\">data</a> to check the format of time value.</li>\n</ul>\n</li>\n<li>displayName: <code class=\"codespan\">string</code>, generally used in tooltip for dimension display. If not specified, use <code class=\"codespan\">name</code> by default.</li>\n</ul>\n</li>\n</ul>\n<p>When <code class=\"codespan\">dimensions</code> is specified, the default <code class=\"codespan\">tooltip</code> will be displayed vertically, which is better to show diemsion names. Otherwise, <code class=\"codespan\">tooltip</code> will displayed only value horizontally.</p>\n"},"encode":{"type":["Object"],"description":"<p>Define what is encoded to for each dimension of <code class=\"codespan\">data</code>. For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // Each column is called a dimension.\n            // There are five dimensions: 0, 1, 2, 3, 4.\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        encode: {\n            x: [3, 1, 5],      // Dimension 3, 1, 5 is mapped to x axis.\n            y: 2,              // Dimension 2 is mapped to y axis.\n            tooltip: [3, 2, 4] // Dimension 3, 2, 4 will be displayed in tooltip.\n        }\n    }\n}\n</code></pre>\n<p>When <a href=\"#series.dimensions\">dimensions</a> is used to defined name for a certain dimension, <code class=\"codespan\">encode</code> can refer the name directly. For example:</p>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;],\n    encode: {\n        x: &#39;date&#39;,\n        y: [&#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<p>The basic structure of <a href=\"option.html#series.encode\" target=\"_blank\">encode</a> is illustrated as follows, where the left part of colon is the name of axis like <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code> or some special reserved names like &quot;tooltip&quot;, &quot;itemName&quot; etc., and the right part of the colon is the dimension names or dimension indices (based on 0). One or more dimensions can be specified. Usually not all of mappings need to be specified, only specify needed ones.</p>\n<p>The properties available in <code class=\"codespan\">encode</code> listed as follows:</p>\n<pre><code class=\"lang-js\">// In any of the series and coordinate systems,\n// these properties are available:\nencode: {\n    // Display dimension &quot;product&quot; and &quot;score&quot; in the tooltip.\n    tooltip: [&#39;product&#39;, &#39;score&#39;]\n    // Set the series name as the concat of the names of dimensions[1] and dimensions[3].\n    // (sometimes the dimension names are too long to type in series.name manually).\n    seriesName: [1, 3],\n    // Using dimensions[2] as the id of each data item. This is useful when dynamically\n    // update data by `chart.setOption()`, where the new and old data item can be\n    // corresponded by id, by which the appropriate animation can be performed when updating.\n    itemId: 2,\n    // Using dimensions[3] as the name of each data item. This is useful in charts like\n    // &#39;pie&#39;, &#39;funnel&#39;, where data item name can be displayed in legend.\n    itemName: 3\n}\n\n// These properties only work in cartesian(grid) coordinate system:\nencode: {\n    // Map dimensions[1], dimensions[5] and dimension &quot;score&quot; to the X axis.\n    x: [1, 5, &#39;score&#39;],\n    // Map dimensions[0] to the Y axis.\n    y: 0\n}\n\n// These properties only work in polar coordinate system:\nencode: {\n    radius: 3,\n    angle: 2,\n    ...\n}\n\n// These properties only work in geo coordinate system:\nencode: {\n    lng: 3,\n    lat: 2\n}\n\n// For some type of series that are not in any coordinate system,\n// like &#39;pie&#39;, &#39;funnel&#39; etc.:\nencode: {\n    value: 3\n}\n</code></pre>\n<p>This is an <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=dataset-encode1&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> for <code class=\"codespan\">encode</code>.</p>\n<p>Specially, in [custom series(~series-custom), some property in <code class=\"codespan\">encode</code>, corresponding to axis, can be set as null to make the series not controlled by the axis, that is, the series data will not be count in the extent of the axis, and the <a href=\"#dataZoom\">dataZoom</a> on the axis will not filter the series.</p>\n<pre><code class=\"lang-js\">var option = {\n    xAxis: {},\n    yAxis: {},\n    dataZoom: [{\n        xAxisIndex: 0\n    }, {\n        yAxisIndex: 0\n    }],\n    series: {\n        type: &#39;custom&#39;,\n        renderItem: function (params, api) {\n            return {\n                type: &#39;circle&#39;,\n                shape: {\n                    cx: 100, // x position is always 100\n                    cy: api.coord([0, api.value(0)])[1],\n                    r: 30\n                },\n                style: {\n                    fill: &#39;blue&#39;\n                }\n            };\n        },\n        encode: {\n            // Then the series will not be controlled\n            // by x axis and corresponding dataZoom.\n            x: -1,\n            y: 1\n        },\n        data: [ ... ]\n    }\n};\n</code></pre>\n"},"data":{"type":["Array"],"description":"<p>Data array of  series, which can be a single data value, like:</p>\n<pre><code class=\"lang-js\">[12, 34, 56, 10, 23]\n</code></pre>\n<p>Or, if need extra dimensions for components like <a href=\"#visualMap\">visualMap</a> to map to graphic attributes like color, it can also be in the form of array. For example:</p>\n<pre><code class=\"lang-js\">[[12, 14], [34, 50], [56, 30], [10, 15], [23, 10]]\n</code></pre>\n<p>In this case, we can assgin the second value in each array item to <a href=\"#visualMap\">visualMap</a> component.</p>\n<p>More likely, we need to assign name to each data item, in which case each item should be an object:</p>\n<pre><code class=\"lang-js\">[{\n    // name of date item\n    name: &#39;data1&#39;,\n    // value of date item is 8\n    value: 10\n}, {\n    name: &#39;data2&#39;,\n    value: 20\n}]\n</code></pre>\n<p>Each data item can be further customized:</p>\n<pre><code class=\"lang-js\">[{\n    name: &#39;data1&#39;,\n    value: 10\n}, {\n    // name of data item\n    name: &#39;data2&#39;,\n    value : 56,\n    // user-defined label format that only useful for this data item\n    label: {},\n    // user-defined special itemStyle that only useful for this data item\n    itemStyle:{}\n}]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>the name of data item.</p>\n"},"value":{"type":["number"],"description":"<p>data value.</p>\n"},"itemStyle":{"type":["Object"],"description":"","properties":{"height":{"type":["string","number"],"description":"<p>Height of this data item. By default, the height is evenly divided for all data items. The height can be set to percentage (e.g.: &#39;10%&#39;) or pixel value (e.g.: 20). Please make sure that the total height of all data items is 100%.</p>\n<p>Graphic style of , <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n"},"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"label":{"type":["Object"],"description":"<p>The label configuration of a single data item.</p>\n","properties":{"show":{"type":["boolean"],"description":"","default":false},"position":{"type":["string"],"description":"<p>Label position.</p>\n<p><strong>Options: </strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code>Left side of funnel chart. Available when <a href=\"#series-funnel.orient\">orient</a> is <code class=\"codespan\">&#39;vertical&#39;</code>.</li>\n<li><code class=\"codespan\">&#39;right&#39;</code> Right side of funnel chart. Available when <a href=\"#series-funnel.orient\">orient</a> is <code class=\"codespan\">&#39;horizontal&#39;</code>.</li>\n<li><code class=\"codespan\">&#39;top&#39;</code> Top side of funnel chart. Available when <a href=\"#series-funnel.orient\">orient</a> is <code class=\"codespan\">&#39;vertical&#39;</code>.</li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code> Bottom side of funnel chart. Available when <a href=\"#series-funnel.orient\">orient</a> is <code class=\"codespan\">&#39;vertical&#39;</code>.</li>\n<li><code class=\"codespan\">&#39;inside&#39;</code>Inside the trapezoid of funnel chart.</li>\n<li><code class=\"codespan\">&#39;insideRight&#39;</code>Right inside the trapezoid of funnel chart.</li>\n<li><code class=\"codespan\">&#39;insideLeft&#39;</code>Left inside the trapezoid of funnel chart.</li>\n<li><code class=\"codespan\">&#39;leftTop&#39;</code>Top-left of funnel chart.</li>\n<li><code class=\"codespan\">&#39;leftBottom&#39;</code>Bottom-left of funnel chart.</li>\n<li><code class=\"codespan\">&#39;rightTop&#39;</code>Top-right side of funnel chart.</li>\n<li><code class=\"codespan\">&#39;rightBottom&#39;</code>Bottom-right side of funnel chart.</li>\n<li><code class=\"codespan\">&#39;inner&#39;</code> equals to <code class=\"codespan\">&#39;inside&#39;</code>.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code> equals to <code class=\"codespan\">&#39;inside&#39;</code>.</li>\n</ul>\n<p><a href=\"#series-funnel.labelLine\">labelLine</a> can be used to guide to the corresponding trapezoid when label is not inside.</p>\n","default":"'outside'"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show visual guide line.</p>\n"},"length":{"type":["number"],"description":"<p>The length of the first part from visual guide line.</p>\n"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"","default":false},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // percentage\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show visual guide line.</p>\n"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"","default":false},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // percentage\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show visual guide line.</p>\n"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"","default":false},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // percentage\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether to show visual guide line.</p>\n"},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series data.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}}},"markPoint":{"type":["Object"],"description":"<p>Mark point in a chart.</p>\n","properties":{"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-funnel.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'pin'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-funnel.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":50},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-funnel.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label of mark point.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark point.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Data array for mark points, each of which is an object. Here are some ways to assign mark point position.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-funnel.markPoint.data.x\">x</a>, <a href=\"#series-funnel.markPoint.data.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p><strong>For example: </strong></p>\n<pre><code class=\"lang-js\">data: [\n\n    {\n        name: &#39;screen coordinate&#39;,\n        x: 100,\n        y: 100\n    }\n]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Mark point name.</p>\n","default":"''"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markLine":{"type":["Object"],"description":"<p>Use a line in the chart to illustrate.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"symbol":{"type":["string","Array"],"description":"<p>Symbol type at the two ends of the mark line. It can be an array for two ends, or assigned seperately. See <a href=\"#series-funnel.markLine.data.0.symbol\">data.symbol</a> for more format information.</p>\n"},"symbolSize":{"type":["number","Array"],"description":"<p>Symbol size at the two ends of the mark line. It can be an array for two ends, or assigned seperately.</p>\n<p><strong>Attention: </strong> You cannot assgin width and height seperately as normal <code class=\"codespan\">symbolSize</code>.</p>\n"},"precision":{"type":["number"],"description":"<p>Precision of marking line value, which is useful when displaying average value mark line.</p>\n","default":2},"label":{"type":["Object"],"description":"<p>Mark line text.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"<p>Mark line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark line.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>Data array of marking line. Every array item can be an array of one or two values, representing starting and ending point of the line, and every item is an object. Here are several ways to assign the positions of starting and ending point.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-funnel.markLine.data.0.x\">x</a>, <a href=\"#series-funnel.markLine.data.0.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<pre><code>data: [\n\n[\n        {\n            name: &#39;Mark line between two points&#39;,\n            x: 100,\n            y: 100\n        },\n        {\n            x: 500,\n            y: 200\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Data of the starting point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'starting point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of starting point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>starting point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of starting point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of starting point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Data of the ending point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'ending point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of ending point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>ending point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of ending point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of ending point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markArea":{"type":["Object"],"description":"<p>Used to mark an area in chart. For example, mark a time interval.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label in mark area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Style of the mark area.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark area.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>The scope of the area is defined by <code class=\"codespan\">data</code>, which is an array with two item, representing the left-top point and the right-bottom point of rectangle area. Each item can be defined as follows:</p>\n<ol>\n<li>Specify the coordinate in screen coordinate system using <a href=\"#series-funnel.markArea.data.0.x\">x</a>, <a href=\"#series-funnel.markArea.data.0.y\">y</a>, where the unit is pixel (e.g., the value is <code class=\"codespan\">5</code>), or percent (e.g., the value is <code class=\"codespan\">&#39;35%&#39;</code>).</li>\n</ol>\n<p>The priority follows as above if more than one above definition used.</p>\n<pre><code>data: [\n\n[\n        {\n            name: &#39;Mark area in two screen points&#39;,\n            x: 100,\n            y: 100\n        }, {\n            x: &#39;90%&#39;,\n            y: &#39;10%&#39;\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Specify the left-top point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'start'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Specify the right-bottom point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'end'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"false","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p><strong>Gauge chart</strong></p>\n<p><strong>Example: </strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=gauge&reset=1&edit=1\" width=\"600\" height=\"500\"></iframe>\n\n","properties":{"type":{"type":["string"],"description":"","default":"'gauge'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"center":{"type":["Array"],"description":"\n\n<p>Center position of , the first of which is the horizontal position, and the second is the vertical position.</p>\n<p>Percentage is supported. When set in percentage, the item is relative to the container width, and the second item to the height.</p>\n<p><strong>Example: </strong></p>\n<pre><code>// Set to absolute pixel values\ncenter: [400, 300]\n// Set to relative percent\ncenter: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>","uiControl":{"type":"percentvector","dims":"x,y"},"default":"['50%', '50%']"},"radius":{"type":["number","string"],"description":"\n\n<p>The radius of gauge chart. It can be a percentage value of the smaller of container half width and half height, also can be an absolute value.</p>\n","uiControl":{"type":"percent","default":"75%"},"default":"'75%'"},"legendHoverLink":{"type":["boolean"],"description":"\n\n<p>Whether to enable highlighting chart when <a href=\"#legend\">legend</a> is being hovered.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"startAngle":{"type":["number"],"description":"\n\n<p>The start angle of gauge chart. The direct right side of <a href=\"#series-gauge.center\">circle center</a> is <code class=\"codespan\">0</code> degree, the right above it is <code class=\"codespan\">90</code> degree, the direct left side of it is <code class=\"codespan\">180</code> degree.</p>\n","uiControl":{"type":"angle","min":"-360","max":"360","default":"225","step":"1"},"default":225},"endAngle":{"type":["number"],"description":"\n\n<p>The end angle of gauge chart.</p>\n","uiControl":{"type":"angle","min":"-360","max":"360","default":"-45","step":"1"},"default":-45},"clockwise":{"type":["boolean"],"description":"\n\n<p>Whether the scale in gauge chart increases clockwise.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"data":{"type":["Array"],"description":"<p>Data array of  series, which can be a single data value, like:</p>\n<pre><code class=\"lang-js\">[12, 34, 56, 10, 23]\n</code></pre>\n<p>Or, if need extra dimensions for components like <a href=\"#visualMap\">visualMap</a> to map to graphic attributes like color, it can also be in the form of array. For example:</p>\n<pre><code class=\"lang-js\">[[12, 14], [34, 50], [56, 30], [10, 15], [23, 10]]\n</code></pre>\n<p>In this case, we can assgin the second value in each array item to <a href=\"#visualMap\">visualMap</a> component.</p>\n<p>More likely, we need to assign name to each data item, in which case each item should be an object:</p>\n<pre><code class=\"lang-js\">[{\n    // name of date item\n    name: &#39;data1&#39;,\n    // value of date item is 8\n    value: 10\n}, {\n    name: &#39;data2&#39;,\n    value: 20\n}]\n</code></pre>\n<p>Each data item can be further customized:</p>\n<pre><code class=\"lang-js\">[{\n    name: &#39;data1&#39;,\n    value: 10\n}, {\n    // name of data item\n    name: &#39;data2&#39;,\n    value : 56,\n    // user-defined label format that only useful for this data item\n    label: {},\n    // user-defined special itemStyle that only useful for this data item\n    itemStyle:{}\n}]\n</code></pre>\n","items":{"type":"Object","properties":{"title":{"type":["Object"],"description":"<p>The title of gauge chart.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the title.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"offsetCenter":{"type":["Array"],"description":"\n\n<p>The offset position relative to the center of gauge chart. The first item of array is the horizontal offset; the second item of array is the vertical offset. It could be absolute value and also the percentage relative to the radius of gauge chart.</p>\n","uiControl":{"type":"percentvector","default":"0,20%","dims":"x,y"},"default":"[0, '20%']"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#464646'"},"default":"'#464646'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"16","min":"1","step":"1"},"default":16},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}},"valueAnimation":{"type":["boolean"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Whether to enable text animation of value change.</p>\n","default":true}}},"detail":{"type":["Object"],"description":"<p>The detail about gauge chart which is used to show data.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the details.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"color":{"type":["Color"],"description":"\n\n<p>The text color. Defaults to use <a href=\"#series-gauge.axisLine.lineStyle.color\">the color of section</a> where the numerical value belongs to.</p>\n","uiControl":{"type":"color"},"default":"'#464646'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"'bold'"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"30","min":"1","step":"1"},"default":30},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"},"default":30},"backgroundColor":{"type":["Color"],"description":"\n\n<p>The background color of detail.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color of detail.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of detail.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>The width of detail.</p>\n","uiControl":{"type":"percent","default":"100","min":"0","step":"1"},"default":100},"height":{"type":["number"],"description":"\n\n<p>The height of detail.</p>\n","uiControl":{"type":"percent","default":"40","min":"0","step":"1"},"default":40},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}},"valueAnimation":{"type":["boolean"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Whether to enable text animation of value change.</p>\n","default":true},"offsetCenter":{"type":["Array"],"description":"\n\n<p>The offset position relative to the center of gauge chart. The first item of array is the horizontal offset; the second item of array is the vertical offset. It could be absolute value and also the percentage relative to the radius of gauge chart.</p>\n","uiControl":{"type":"percentvector","default":"0,-40%","dims":"x,y"},"default":"[0, '40%']"},"formatter":{"type":["Function","string"],"description":"<p>Formatter is used to format detail, which supports string template and callback function.</p>\n<pre><code class=\"lang-js\">formatter: function (value) {\n    return value.toFixed(0);\n}\n</code></pre>\n"}}},"name":{"type":["string"],"description":"<p>Data name.</p>\n"},"value":{"type":["number"],"description":"\n\n<p>Data value.</p>\n","uiControl":{"type":"number","default":"0","step":"1"}},"itemStyle":{"type":["Object"],"description":"<p>The style of data pointer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}}}}},"min":{"type":["number"],"description":"\n\n<p>The minimum data value which map to <a href=\"#series-gauge.minAngle\">minAngle</a>.</p>\n","uiControl":{"type":"number","default":"0","step":"1"},"default":0},"max":{"type":["number"],"description":"\n\n<p>The maximum data value which map to  <a href=\"#series-gauge.maxAngle\">maxAngle</a>.</p>\n","uiControl":{"type":"number","default":"100","step":"1"},"default":100},"splitNumber":{"type":["number"],"description":"\n\n<p>The number of split segments of gauge chart scale.</p>\n","uiControl":{"type":"number","min":"1","default":"10","step":"1"},"default":10},"axisLine":{"type":["Object"],"description":"<p>The related configuration about the axis line of gauge chart.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the axis line of gauge chart.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"roundCap":{"type":["boolean"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Whether to add round caps at the end.</p>\n","default":false},"lineStyle":{"type":["Object"],"description":"<p>The style of the axis line of gauge chart.</p>\n","properties":{"color":{"type":["Array"],"description":"<p>The axis line of gauge chart can be divided to several segments in different colors. The end position and color of each segment can be expressed by an array.</p>\n<p>Default value:</p>\n<pre><code class=\"lang-js\">[[1, &#39;#E6EBF8&#39;]]\n</code></pre>\n"},"width":{"type":["number"],"description":"<p>The width of axis line.</p>\n","default":10},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"progress":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0</code></p>\n</blockquote>\n<p>Used to show current progress.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the progress of gauge chart.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":false},"overlap":{"type":["boolean"],"description":"\n\n<p>Whether the progress overlaps when there are multiple groups of data.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"width":{"type":["number"],"description":"\n\n<p>The width of progress.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":10},"roundCap":{"type":["boolean"],"description":"<p>Whether to add round caps at the end</p>\n","default":false},"clip":{"type":["boolean"],"description":"<p>Whether to clip overflow.</p>\n","default":false},"itemStyle":{"type":["Object"],"description":"<p>The style of progress.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"splitLine":{"type":["Object"],"description":"<p>The style of split line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the split line.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"length":{"type":["number","string"],"description":"\n\n<p>The length of split line, can be a pecentage value relative to radius.</p>\n","uiControl":{"type":"percent","default":"10","min":"0","step":"0.5"},"default":10},"distance":{"type":["number"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0</code></p>\n</blockquote>\n\n\n<p>The distance between the split line and axis line.</p>\n","uiControl":{"type":"number","default":"10","min":"0","step":"0.5"},"default":10},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#63677A"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"3","min":"0","step":"0.5"},"default":3},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisTick":{"type":["Object"],"description":"<p>The tick line style.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the scale.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"splitNumber":{"type":["number"],"description":"\n\n<p>The split scale number between split line.</p>\n","uiControl":{"type":"number","min":"1","default":"5","step":"1"},"default":5},"length":{"type":["number","string"],"description":"\n\n<p>The length of tick line, can be a pecentage value relative to radius.</p>\n","uiControl":{"type":"percent","default":"6","min":"0","step":"0.5"},"default":6},"distance":{"type":["number"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0</code></p>\n</blockquote>\n\n\n<p>The distance between the tick line and axis line.</p>\n","uiControl":{"type":"number","default":"10","min":"0","step":"0.5"},"default":10},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"#63677A"},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":1},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"axisLabel":{"type":["Object"],"description":"<p>Axis tick label.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"distance":{"type":["number"],"description":"\n\n<p>The distance between the label and tick line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"0.5"},"default":15},"formatter":{"type":["string","Function"],"description":"<p>The content formatter of scale label, which supports both string template and callback function.\nExample:</p>\n<pre><code class=\"lang-js\">// use string template. the template variable {value} represent the default label text\nformatter: &#39;{value} kg&#39;\n\n// use function callback. the function parameters are scale values.\nformatter: function (value) {\n    return value + &#39;km/h&#39;;\n}\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#464646'"},"default":"'#464646'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"pointer":{"type":["Object"],"description":"<p>Gauge chart pointer.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the pointer.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"icon":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0</code></p>\n</blockquote>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","default":null},"offsetCenter":{"type":["Array"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0</code></p>\n</blockquote>\n\n\n<p>The offset position relative to the center of gauge chart. The first item of array is the horizontal offset; the second item of array is the vertical offset. It could be absolute value and also the percentage relative to the radius of gauge chart.</p>\n","uiControl":{"type":"percentvector","default":"0,0","dims":"x,y"},"default":"[0, 0]"},"length":{"type":["string","number"],"description":"\n\n<p>The length of pointer which could be absolute value and also the percentage relative to <a href=\"#series-gauge.radius\">radius</a>.</p>\n","uiControl":{"type":"percent","default":"60%","min":"0","step":"0.5"},"default":"'60%'"},"width":{"type":["number"],"description":"\n\n<p>The width of pointer.</p>\n","uiControl":{"type":"number","default":"6","min":"0","step":"0.5"},"default":6},"keepAspect":{"type":["boolean"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0</code></p>\n</blockquote>\n\n\n<p>Whether to keep aspect for icons in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"itemStyle":{"type":["Object"],"description":"<p>The style of pointer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"anchor":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0</code></p>\n</blockquote>\n<p>The fixed point of a pointer in a dial.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the anchor.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"showAbove":{"type":["boolean"],"description":"\n\n<p>Whether the anchor is showed above the pointer.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"size":{"type":["number"],"description":"\n\n<p>The size of anchor.</p>\n","uiControl":{"type":"number","default":"6","min":"0","step":"0.5"},"default":6},"icon":{"type":["string"],"description":"<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","default":"'default'"},"offsetCenter":{"type":["Array"],"description":"\n\n<p>The offset position relative to the center of gauge chart. The first item of array is the horizontal offset; the second item of array is the vertical offset. It could be absolute value and also the percentage relative to the radius of gauge chart.</p>\n","uiControl":{"type":"percentvector","default":"0,0","dims":"x,y"},"default":"[0, 0]"},"keepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for icons in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"itemStyle":{"type":["Object"],"description":"<p>The style of anchor.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"'#fff'"},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color of anchor.</p>\n","uiControl":{"type":"color","default":"#5470c6"},"default":"'#5470c6'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>The style of gauge chart.</p>\n","properties":{"color":{"type":["Color"],"description":"<p>The color of pointer. Defaults to use <a href=\"#series-gauge.axisLine.lineStyle.color\">the color of section</a> where the numerical value belongs to.</p>\n","default":"'auto'"},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n\n","default":512}}}}},"emphasis":{"type":["Object"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"title":{"type":["Object"],"description":"<p>The title of gauge chart.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the title.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"offsetCenter":{"type":["Array"],"description":"\n\n<p>The offset position relative to the center of gauge chart. The first item of array is the horizontal offset; the second item of array is the vertical offset. It could be absolute value and also the percentage relative to the radius of gauge chart.</p>\n","uiControl":{"type":"percentvector","default":"0,20%","dims":"x,y"},"default":"[0, '20%']"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#464646'"},"default":"'#464646'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"16","min":"1","step":"1"},"default":16},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}},"valueAnimation":{"type":["boolean"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Whether to enable text animation of value change.</p>\n","default":true}}},"detail":{"type":["Object"],"description":"<p>The detail about gauge chart which is used to show data.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the details.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"color":{"type":["Color"],"description":"\n\n<p>The text color. Defaults to use <a href=\"#series-gauge.axisLine.lineStyle.color\">the color of section</a> where the numerical value belongs to.</p>\n","uiControl":{"type":"color"},"default":"'#464646'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"'bold'"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"30","min":"1","step":"1"},"default":30},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"},"default":30},"backgroundColor":{"type":["Color"],"description":"\n\n<p>The background color of detail.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color of detail.</p>\n","uiControl":{"type":"color","default":"#ccc"},"default":"'#ccc'"},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of detail.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>The width of detail.</p>\n","uiControl":{"type":"percent","default":"100","min":"0","step":"1"},"default":100},"height":{"type":["number"],"description":"\n\n<p>The height of detail.</p>\n","uiControl":{"type":"percent","default":"40","min":"0","step":"1"},"default":40},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}},"valueAnimation":{"type":["boolean"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Whether to enable text animation of value change.</p>\n","default":true},"offsetCenter":{"type":["Array"],"description":"\n\n<p>The offset position relative to the center of gauge chart. The first item of array is the horizontal offset; the second item of array is the vertical offset. It could be absolute value and also the percentage relative to the radius of gauge chart.</p>\n","uiControl":{"type":"percentvector","default":"0,-40%","dims":"x,y"},"default":"[0, '40%']"},"formatter":{"type":["Function","string"],"description":"<p>Formatter is used to format detail, which supports string template and callback function.</p>\n<pre><code class=\"lang-js\">formatter: function (value) {\n    return value.toFixed(0);\n}\n</code></pre>\n"}}},"markPoint":{"type":["Object"],"description":"<p>Mark point in a chart.</p>\n","properties":{"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-gauge.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'pin'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-gauge.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":50},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-gauge.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label of mark point.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark point.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Data array for mark points, each of which is an object. Here are some ways to assign mark point position.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-gauge.markPoint.data.x\">x</a>, <a href=\"#series-gauge.markPoint.data.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p><strong>For example: </strong></p>\n<pre><code class=\"lang-js\">data: [\n\n    {\n        name: &#39;screen coordinate&#39;,\n        x: 100,\n        y: 100\n    }\n]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Mark point name.</p>\n","default":"''"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markLine":{"type":["Object"],"description":"<p>Use a line in the chart to illustrate.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"symbol":{"type":["string","Array"],"description":"<p>Symbol type at the two ends of the mark line. It can be an array for two ends, or assigned seperately. See <a href=\"#series-gauge.markLine.data.0.symbol\">data.symbol</a> for more format information.</p>\n"},"symbolSize":{"type":["number","Array"],"description":"<p>Symbol size at the two ends of the mark line. It can be an array for two ends, or assigned seperately.</p>\n<p><strong>Attention: </strong> You cannot assgin width and height seperately as normal <code class=\"codespan\">symbolSize</code>.</p>\n"},"precision":{"type":["number"],"description":"<p>Precision of marking line value, which is useful when displaying average value mark line.</p>\n","default":2},"label":{"type":["Object"],"description":"<p>Mark line text.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"<p>Mark line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark line.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>Data array of marking line. Every array item can be an array of one or two values, representing starting and ending point of the line, and every item is an object. Here are several ways to assign the positions of starting and ending point.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-gauge.markLine.data.0.x\">x</a>, <a href=\"#series-gauge.markLine.data.0.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<pre><code>data: [\n\n[\n        {\n            name: &#39;Mark line between two points&#39;,\n            x: 100,\n            y: 100\n        },\n        {\n            x: 500,\n            y: 200\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Data of the starting point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'starting point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of starting point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>starting point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of starting point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of starting point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Data of the ending point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'ending point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of ending point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>ending point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of ending point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of ending point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markArea":{"type":["Object"],"description":"<p>Used to mark an area in chart. For example, mark a time interval.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label in mark area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Style of the mark area.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark area.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>The scope of the area is defined by <code class=\"codespan\">data</code>, which is an array with two item, representing the left-top point and the right-bottom point of rectangle area. Each item can be defined as follows:</p>\n<ol>\n<li>Specify the coordinate in screen coordinate system using <a href=\"#series-gauge.markArea.data.0.x\">x</a>, <a href=\"#series-gauge.markArea.data.0.y\">y</a>, where the unit is pixel (e.g., the value is <code class=\"codespan\">5</code>), or percent (e.g., the value is <code class=\"codespan\">&#39;35%&#39;</code>).</li>\n</ol>\n<p>The priority follows as above if more than one above definition used.</p>\n<pre><code>data: [\n\n[\n        {\n            name: &#39;Mark area in two screen points&#39;,\n            x: 100,\n            y: 100\n        }, {\n            x: &#39;90%&#39;,\n            y: &#39;10%&#39;\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Specify the left-top point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'start'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Specify the right-bottom point.</p>\n","properties":{"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'end'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"false","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p><strong>pictorial bar chart</strong></p>\n<p>Pictorial bar chart is a type of bar chart that customized glyph (like images, <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a>) can be used instead of rectangular bar. This kind of chart is usually used in infographic.</p>\n<p>Pictorial bar chart can only be used in <a href=\"#grid\">rectangular coordinate</a> with at least 1 category axis.</p>\n<p><strong>Example:</strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=pictorialBar-hill&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n<p><strong>Layout</strong></p>\n<p>Basically <code class=\"codespan\">pictoialBar</code> is a type of bar chart, which follows the bar chart layout. In <code class=\"codespan\">pictorialBar</code>, each bar is named as <code class=\"codespan\">reference bar</code>, which does not be shown, but only be used as a reference for layout of pictorial graphic elements. Each pictorial graphic element is positioned with respect to its <code class=\"codespan\">reference bar</code> according to the setting of <a href=\"#series-pictorialBar.symbolPosition\">symbolPosition</a>、<a href=\"#series-pictorialBar.symbolOffset\">symbolOffset</a>.</p>\n<p>See the example below:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-position&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n<p><a href=\"#series-pictorialBar.symbolSize\">symbolSize</a> is used to specify the size of graphic elements.</p>\n<p>See the example below:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-symbolSize&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n\n\n<p><strong>Graphic types</strong></p>\n<p><a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> can be</p>\n<p>Graphic elements can be set as &#39;repeat&#39; or not by <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a>.</p>\n<ul>\n<li>If set as <code class=\"codespan\">false</code> (default), a single graphic element is used to represent a data item.</li>\n<li>If set as <code class=\"codespan\">true</code>, a group of repeat graphic elements are used to represent a data item.</li>\n</ul>\n<p>See the example below:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-repeat&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n<p>Each graphic element can be basic shape (like <code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, ...), or <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a>, or image. See <a href=\"#series-pictorialBar.symbolType\">symbolType</a>.</p>\n<p>See the example below:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-graphicType&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n<p><a href=\"#series-pictorialBar.symbolClip\">symbolClip</a> can be used to clip graphic elements.</p>\n<p>See the example below:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-clip&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n","properties":{"type":{"type":["string"],"description":"","default":"'pictorialBar'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"legendHoverLink":{"type":["boolean"],"description":"\n\n<p>Whether to enable highlighting chart when <a href=\"#legend\">legend</a> is being hovered.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"coordinateSystem":{"type":["string"],"description":"<p>The coordinate used in the series, whose options are:</p>\n<ul>\n<li><p><code class=\"codespan\">&#39;cartesian2d&#39;</code></p>\n<p>  Use a two-dimensional rectangular coordinate (also known as Cartesian coordinate), with <a href=\"#series-pictorialBar.xAxisIndex\">xAxisIndex</a> and <a href=\"#series-pictorialBar.yAxisIndex\">yAxisIndex</a> to assign the corresponding axis component.</p>\n</li>\n</ul>\n","default":"'cartesian2d'"},"xAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#xAxis\">x axis</a> to combine with, which is  useful for multiple x axes in one chart.</p>\n","default":0},"yAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#yAxis\">y axis</a> to combine with, which is  useful for multiple y axes in one chart.</p>\n","default":0},"cursor":{"type":["string"],"description":"\n\n<p>The mouse style when mouse hovers on an element, the same as <code class=\"codespan\">cursor</code> property in <code class=\"codespan\">CSS</code>.</p>\n","uiControl":{"type":"enum","options":"auto,pointer,move","default":"pointer"},"default":"'pointer'"},"label":{"type":["Object"],"description":"<p>Text label of , to explain some data information about graphic item like value, name and so on. <code class=\"codespan\">label</code> is placed under <code class=\"codespan\">itemStyle</code> in ECharts 2.x. In ECharts 3, to make the configuration structure flatter, <code class=\"codespan\">label</code>is taken to be at the same level with <code class=\"codespan\">itemStyle</code>, and has <code class=\"codespan\">emphasis</code> as <code class=\"codespan\">itemStyle</code> does.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of , <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"emphasis":{"type":["Object"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Available when <a href=\"#series-pictoialBar.emphasis.focus\">emphasis.focus</a> is set.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of select state. Available when <a href=\"#series-pictoialBar.selectedMode\">selectedMode</a> is set.</p>\n"},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false,"properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"barWidth":{"type":["number","string"],"description":"<p>The width of the bar. Adaptive when not specified.</p>\n\n\n\n\n<p>Can be an absolute value like <code class=\"codespan\">40</code> or a percent value like <code class=\"codespan\">&#39;60%&#39;</code>. The percent is based on the calculated category width.</p>\n<p>In a single coodinate system, this attribute is shared by multiple <code class=\"codespan\">&#39;pictorialBar&#39;</code> series. This attribute should be set on the last <code class=\"codespan\">&#39;pictorialBar&#39;</code> series in the coodinate system, then it will be adopted by all <code class=\"codespan\">&#39;pictorialBar&#39;</code> series in the coordinate system.</p>\n","uiControl":{"type":"percent"},"default":null},"barMaxWidth":{"type":["number","string"],"description":"<p>The maximum width of the bar.</p>\n<p>Has higer priority than <a href=\"#series-bar.barWidth\">barWidth</a>.</p>\n<p>Can be an absolute value like <code class=\"codespan\">40</code> or a percent value like <code class=\"codespan\">&#39;60%&#39;</code>. The percent is based on the calculated category width.</p>\n<p>In a single coodinate system, this attribute is shared by multiple <code class=\"codespan\">&#39;pictorialBar&#39;</code> series. This attribute should be set on the last <code class=\"codespan\">&#39;pictorialBar&#39;</code> series in the coodinate system, then it will be adopted by all <code class=\"codespan\">&#39;pictorialBar&#39;</code> series in the coordinate system.</p>\n","default":null},"barMinWidth":{"type":["number","string"],"description":"<p>The minimum width of the bar. In cartesian the default value is <code class=\"codespan\">1</code>, otherwise the default value if <code class=\"codespan\">null</code>.</p>\n<p>Has higer priority than <a href=\"#series-bar.barWidth\">barWidth</a>.</p>\n<p>Can be an absolute value like <code class=\"codespan\">40</code> or a percent value like <code class=\"codespan\">&#39;60%&#39;</code>. The percent is based on the calculated category width.</p>\n<p>In a single coodinate system, this attribute is shared by multiple <code class=\"codespan\">&#39;pictorialBar&#39;</code> series. This attribute should be set on the last <code class=\"codespan\">&#39;pictorialBar&#39;</code> series in the coodinate system, then it will be adopted by all <code class=\"codespan\">&#39;pictorialBar&#39;</code> series in the coordinate system.</p>\n"},"barMinHeight":{"type":["number"],"description":"<p>The minimum width of bar. It could be used to avoid the following situation: the interaction would be affected when the value of some data item is too small.</p>\n\n","uiControl":{"type":"number","min":"0"},"default":0},"barGap":{"type":["string"],"description":"<p>The gap between bars between different series, is a percent value like <code class=\"codespan\">&#39;30%&#39;</code>, which means <code class=\"codespan\">30%</code> of the bar width.</p>\n<p>Set barGap as <code class=\"codespan\">&#39;-100%&#39;</code> can overlap bars that belong to different series, which is useful when making a series of bar be background.</p>\n<p>In a single coodinate system, this attribute is shared by multiple <code class=\"codespan\">&#39;pictorialBar&#39;</code> series. This attribute should be set on the last <code class=\"codespan\">&#39;pictorialBar&#39;</code> series in the coodinate system, then it will be adopted by all <code class=\"codespan\">&#39;pictorialBar&#39;</code> series in the coordinate system.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/barGrid-barGap&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"-100%"},"barCategoryGap":{"type":["string"],"description":"<p>The bar gap of a single series, defaults to be <code class=\"codespan\">20%</code> of the category gap, can be set as a fixed value.</p>\n<p>In a single coodinate system, this attribute is shared by multiple <code class=\"codespan\">&#39;pictorialBar&#39;</code> series. This attribute should be set on the last <code class=\"codespan\">&#39;pictorialBar&#39;</code> series in the coodinate system, then it will be adopted by all <code class=\"codespan\">&#39;pictorialBar&#39;</code> series in the coordinate system.</p>\n","default":"'20%'"},"symbol":{"type":["string"],"description":"<p>Specify the type of graphic elements.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>Example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-graphicType&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbol\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbol\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbol: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbol: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbol: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","default":"'circle'"},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>Symbol size.</p>\n<p>It can be set as a array, which means [width, height]. For example, <code class=\"codespan\">[20, 10]</code> means width <code class=\"codespan\">20</code> and height <code class=\"codespan\">10</code>. It can also be set as a single number, like <code class=\"codespan\">10</code>, which is equivalent to <code class=\"codespan\">[10, 10]</code>.</p>\n<p>Absolute value can be used (like <code class=\"codespan\">10</code>), or percent value can be used (like <code class=\"codespan\">&#39;120%&#39;</code>, <code class=\"codespan\">[&#39;55%&#39;, 23]</code>).</p>\n<p>When percent value is used, final size of the graphic element is calculated based on its <a href=\"#series-pictorialBar\">reference bar</a>.</p>\n<p>For example, there is a reference bar based on x axis (that is, it is a vertical bar), and <a href=\"#series-pictorialBar.symbolSize\">symbolSize</a> is set as <code class=\"codespan\">[&#39;30%&#39;, &#39;50%&#39;]</code>, the final size of its graphic elements is:</p>\n<ul>\n<li>width: <code class=\"codespan\">&lt;width of reference bar&gt; * 30%</code>.</li>\n<li>height:<ul>\n<li>If <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is used: <code class=\"codespan\">&lt;height of reference bar&gt; * 50%</code>.</li>\n<li>If <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is not used: <code class=\"codespan\">&lt;height of reference bar&gt; * 50%</code>.</li>\n</ul>\n</li>\n</ul>\n<p>Analogously, the case that based on y axis can be obtained by exchanging them.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-symbolSize&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolSize\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolSize\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolSize: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolSize: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolSize: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"percent","default":"100%,100%","dims":"W,H"},"default":"['100%', '100%']"},"symbolPosition":{"type":["string"],"description":"\n\n<p>Specify the location of the graphic elements. Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code>: The edge of graphic element inscribes with the start of the reference bar.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code>: The edge of graphic element inscribes with the end of the reference bar.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: The graphic element is at the center of the reference bar.</li>\n</ul>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-position&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolPosition\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolPosition\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolPosition: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolPosition: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolPosition: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"enum","options":"start,end,center","default":"start"},"default":"'start'"},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Specify the offset of graphic element according to its original position. Adopting <code class=\"codespan\">symbolOffset</code> is the final step in layout, which enables adjustment of graphic element position.</p>\n<p>A absolute value can be set (like <code class=\"codespan\">10</code>), or a percent value can be set (like <code class=\"codespan\">&#39;120%&#39;</code>、<code class=\"codespan\">[&#39;55%&#39;, 23]</code>), which is based on its <a href=\"#series-pictorialBar.symbolSize\">symbolSize</a>.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;-50%&#39;]</code> means the graphic element will be adjusted upward half of the size of itself.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-position&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolOffset\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolOffset\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolOffset: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolOffset: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolOffset: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"percentvector","default":"0,0","dims":"x,y"},"default":"[0, 0]"},"symbolRotate":{"type":["number"],"description":"\n\n<p>The degree of the rotation of a graphic element.</p>\n<p>Notice, <code class=\"codespan\">symbolRotate</code> will not affect the position of the graphic element, but just rotating by its center.</p>\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolRotate\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolRotate\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolRotate: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolRotate: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolRotate: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"angle","min":"-360","max":"360","step":"1"}},"symbolRepeat":{"type":["boolean","number","string"],"description":"\n\n<p>Whether to repeat a graphic element. Optional values:</p>\n<ul>\n<li><code class=\"codespan\">false</code>/<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code>: Do not repeat, that is, each graphic element represents a data item.</li>\n<li><code class=\"codespan\">true</code>: Repeat, that is, a group of repeated graphic elements represent a data item. The repeat times is calculated according to <a href=\"#series-pictorialBar.data\">data</a>.</li>\n<li>a number: Repeat, that is a group of repeated graphic elements represent a data item. The repeat times is always the given number.</li>\n<li><code class=\"codespan\">&#39;fixed&#39;</code>: Repeat, that is a group of repeated graphic elements represent a data item. The repeat times is calcuated according to <a href=\"#series-pictorialBar.symbolBoundingData\">symbolBoundingData</a>, that is, the repeat times has nothing to do with <a href=\"#series-pictorialBar.data\">data</a>. The setting is useful when graphic elements are used as background.</li>\n</ul>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-repeat&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolRepeat\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolRepeat\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolRepeat: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolRepeat: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolRepeat: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"enum","options":"true,false,fixed"}},"symbolRepeatDirection":{"type":["string"],"description":"\n\n<p>When <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is used, <code class=\"codespan\">symbolRepeatDirection</code> specifies the render order of the repeated graphic elements. The setting is useful in these cases below:</p>\n<ul>\n<li><p>If <a href=\"#series-pictorialBar.symbolMargin\">symbolMargin</a> is set as a negative value, repeated elements will overlap with each other. <code class=\"codespan\">symbolRepeatDirection</code> can be used to specify the order of overlap.</p>\n</li>\n<li><p>If <a href=\"#series-pictorialBar.animationDelay\">animationDelay</a> or <a href=\"#series-pictorialBar.animationDelayUpdate\">animationDelayUpdate</a> is used, <code class=\"codespan\">symbolRepeatDirection</code> specifies the order of index.</p>\n</li>\n</ul>\n<p>Optional values can be <code class=\"codespan\">&#39;start&#39;</code> and <code class=\"codespan\">&#39;end&#39;</code>.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-repeatDirection&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolRepeatDirection\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolRepeatDirection\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolRepeatDirection: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolRepeatDirection: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolRepeatDirection: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"enum","options":"start,end","default":"start"},"default":"'start'"},"symbolMargin":{"type":["number","string"],"description":"\n\n<p>Specify margin of both sides of a graphic element. (&quot;both sides&quot; means the two sides in the direction of its value axis). It works only when <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is used.</p>\n<p>Absolute value can be used (like <code class=\"codespan\">20</code>), or percent value can be used (like <code class=\"codespan\">&#39;-30%&#39;</code>), which is based on its <a href=\"#series-pictorialBar.symbolSize\">symbolSize</a>.</p>\n<p><code class=\"codespan\">symbolMargin</code> can be positive value or negative value, which enables overlap of graphic elements when <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is used.</p>\n<p>A <code class=\"codespan\">&quot;!&quot;</code> can be appended on the end of the value, like <code class=\"codespan\">&quot;30%!&quot;</code> or <code class=\"codespan\">25!</code>, which means a extra blank will be added on the both ends, otherwise the graphic elements on both ends will reach the boundary by default.</p>\n<p>Notice:</p>\n<ul>\n<li>When <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is <code class=\"codespan\">true</code>/<code class=\"codespan\">&#39;fixed&#39;</code>:\n  The given <code class=\"codespan\">symbolMargin</code> is just a reference value. The final gap of graphic elements will be calculated according to <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a>, <code class=\"codespan\">symbolMargin</code> and <a href=\"#series-pictorialBar.symbolBoundingData\">symbolBoundingData</a>.</li>\n<li>When <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is set as a number:\n  <code class=\"codespan\">symbolMargin</code> does not work any more.</li>\n</ul>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-repeatLayout&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolMargin\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolMargin\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolMargin: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolMargin: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolMargin: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"percentvector","default":"0,0","dims":"x,y"}},"symbolClip":{"type":["boolean"],"description":"\n\n<p>Whether to clip graphic elements.</p>\n<ul>\n<li><code class=\"codespan\">false</code>/null/undefined: The whole graphic elements represent the size of value.</li>\n<li><code class=\"codespan\">true</code>: The clipped graphic elements reperent the size of value.</li>\n</ul>\n<p><code class=\"codespan\">symbolClip</code> is usually used in this case: both &quot;amount value&quot; and &quot;current value&quot; should be displayed. In this case, tow series can be used. One for background, using complete graphic elements, while another for current value, using clipped graphic elements.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-clip&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n<p>Notice, in the example above,</p>\n<ul>\n<li>The same <a href=\"#series.pictorialBar.symbolBoundingData\">symbolBoundingData</a> is used in &quot;background series&quot; and &quot;current value seires&quot;, which makes their graphic elements are the same size.</li>\n<li>A bigger <a href=\"#series.pictorialBar.z\">z</a> is set on &quot;current value series&quot;, which makes it is over &quot;background series&quot;.</li>\n</ul>\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolClip\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolClip\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolClip: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolClip: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolClip: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"boolean"},"default":false},"symbolBoundingData":{"type":["number"],"description":"<p>Defines a bounding area availble for the graphic elements. This setting gives a data, which will then be translated to a coordinate on the coordinate system. The coordinate specifies the bounding. Namely, if <code class=\"codespan\">symbolBoundingData</code> is set, the final size (or layout) of the graphic elements depend on the <code class=\"codespan\">symbolBoundingData</code>.</p>\n<p>When reference bar is horizontal, <code class=\"codespan\">symbolBoundingData</code> is coresponding to x axis, while reference bar is vertical, <code class=\"codespan\">symbolBoundingData</code> is coresponding to y axis.</p>\n<p>Rule:</p>\n<ul>\n<li><p>If <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is not used:</p>\n<p>  <code class=\"codespan\">symbolBoundingData</code> is the same as the size of reference bar by default. The size of the graphic element is detemined by <code class=\"codespan\">symbolBoundingData</code>. For example, if reference bar is vertical, its data is <code class=\"codespan\">24</code>, <code class=\"codespan\">symbolSize</code> is set as <code class=\"codespan\">[30, &#39;50%&#39;]</code>, <code class=\"codespan\">symbolBoundingData</code> is set as <code class=\"codespan\">124</code>, the final size of the graphic element will be <code class=\"codespan\">124 * 50% = 62</code>. If <code class=\"codespan\">symbolBoundingData</code> is not set, the final size will be <code class=\"codespan\">24 * 50% = 12</code>.</p>\n</li>\n<li><p>If <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is used:</p>\n<p>  <code class=\"codespan\">symbolBoundingData</code> is the extreme value of the coordinate system. <code class=\"codespan\">symbolBoundingData</code> defines a bounding area, where repeated graphic elements layout according to <a href=\"#series-pictorialBar.symbolMargin\">symbolMargin</a> and <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> and <a href=\"#series-pictorialBar.symbolSize\">symbolSize</a>. Both these settings determine the gap size of the repeated graphic elements.</p>\n</li>\n</ul>\n<p><code class=\"codespan\">symbolBoundingData</code> is usually used in these cases:</p>\n<ul>\n<li><p>When <a href=\"#series-pictorialBar.symbolClip\">symbolCilp</a> is used:</p>\n<p>  And a series is used to display &quot;amont value&quot;, while another series is used to display &quot;current value&quot;. <code class=\"codespan\">symbolBoundingData</code> can be used to ensure that the graphic elements of these two series are at the same size.</p>\n</li>\n</ul>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-clip&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n<ul>\n<li><p>When <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is used:</p>\n<p>  <code class=\"codespan\">symbolBoundingData</code> can be use to ensure the gaps of the elements in different bars are the same. Of cource, you can do not set <code class=\"codespan\">symbolBoundingData</code>, whose default value is a stable value (extreme value of the coordinate system).</p>\n</li>\n</ul>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-repeatLayout&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n<p><br>\n<code class=\"codespan\">symbolBoundingData</code> can also be an array, such as <code class=\"codespan\">[-40, 60]</code>, which specifies both negative and positive symbolBoundingData.</p>\n<p>Check this example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-symbolBoundingDataArray&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolBoundingData\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolBoundingData\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolBoundingData: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolBoundingData: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolBoundingData: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n"},"symbolPatternSize":{"type":["number"],"description":"\n\n<p>Image can be used as the pattern of graphic elements.</p>\n<pre><code class=\"lang-js\">var textureImg = new Image();\ntextureImg.src = &#39;data:image/jpeg;base64,...&#39;; // dataURI\n// Or\n// textureImg.src = &#39;http://xxx.xxx.xxx/xx.png&#39;; // URL\n...\nitemStyle: {\n    color: {\n        image: textureImg,\n        repeat: &#39;repeat&#39;\n    }\n}\n</code></pre>\n<p><code class=\"codespan\">symbolPatternSize</code> specifies the size of pattern image. For example, if <code class=\"codespan\">symbolPatternSize</code> is <code class=\"codespan\">400</code>, the pattern image will be displayed at the size of <code class=\"codespan\">400px * 400px</code>.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-patternSize&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolPatternSize\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolPatternSize\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolPatternSize: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolPatternSize: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolPatternSize: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"number","default":"400","step":"10","min":"0"},"default":400},"hoverAnimation":{"type":["boolean"],"description":"\n\n<p>Whether to enable hover animation.</p>\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.hoverAnimation\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.hoverAnimation\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    hoverAnimation: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        hoverAnimation: ... // Only affect this data item.\n    }, {\n        value: 56\n        hoverAnimation: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"boolean"},"default":false,"properties":{"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Specify the delay time before animation start. Callback function can be used, where different delay time can be used on different element.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (dataIndex, params) {\n    return params.index * 30;\n}\n// Or inverse:\nanimationDelay: function (dataIndex, params) {\n    return (params.count - 1 - params.index) * 30;\n}\n</code></pre>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-repeatDirection&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n","default":0},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Specify the delay time before update animation. Callback function can be used, where different delay time can be used on different element.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (dataIndex, params) {\n    return params.index * 30;\n}\n// Or inverse:\nanimationDelay: function (dataIndex, params) {\n    return (params.count - 1 - params.index) * 30;\n}\n</code></pre>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-repeatDirection&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n\n\n\n\n\n\n\n\n","default":0}}},"dimensions":{"type":["Array"],"description":"<p><code class=\"codespan\">dimensions</code> can be used to define dimension info for <code class=\"codespan\">series.data</code> or <code class=\"codespan\">dataset.source</code>.</p>\n<p>Notice: if <a href=\"#dataset\">dataset</a> is used, we can definite dimensions in <a href=\"#dataset.dimensions\">dataset.dimensions</a>, or provide dimension names in the first column/row of <a href=\"#dataset.source\">dataset.source</a>, and not need to specify <code class=\"codespan\">dimensions</code> here. But if <code class=\"codespan\">dimensions</code> is specified here, it will be used despite the dimension definitions in dataset.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // &#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        // Specify name for each dimesions, which will be displayed in tooltip.\n        dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [\n        null,                // If you do not intent to defined this dimension, use null is fine.\n        {type: &#39;ordinal&#39;},   // Specify type of this dimension.\n                             // &#39;ordinal&#39; is always used in string.\n                             // If type is not specified, echarts will guess type by data.\n        {name: &#39;good&#39;, type: &#39;number&#39;},\n        &#39;bad&#39;                // Equals to {name: &#39;bad&#39;}.\n    ]\n}\n</code></pre>\n<p>Each data item of <code class=\"codespan\">dimensions</code> can be:</p>\n<ul>\n<li><code class=\"codespan\">string</code>, for example, <code class=\"codespan\">&#39;someName&#39;</code>, which equals to <code class=\"codespan\">{name: &#39;someName&#39;}</code>.</li>\n<li><code class=\"codespan\">Object</code>, where the attributes can be:<ul>\n<li>name: <code class=\"codespan\">string</code>.</li>\n<li>type: <code class=\"codespan\">string</code>, supports:<ul>\n<li><code class=\"codespan\">number</code></li>\n<li><code class=\"codespan\">float</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array\" target=\"_blank\">Float64Array</a></li>\n<li><code class=\"codespan\">int</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array\" target=\"_blank\">Int32Array</a></li>\n<li><code class=\"codespan\">ordinal</code>, discrete value, which represents string generally.</li>\n<li><code class=\"codespan\">time</code>, time value, see <a href=\"#series.data\">data</a> to check the format of time value.</li>\n</ul>\n</li>\n<li>displayName: <code class=\"codespan\">string</code>, generally used in tooltip for dimension display. If not specified, use <code class=\"codespan\">name</code> by default.</li>\n</ul>\n</li>\n</ul>\n<p>When <code class=\"codespan\">dimensions</code> is specified, the default <code class=\"codespan\">tooltip</code> will be displayed vertically, which is better to show diemsion names. Otherwise, <code class=\"codespan\">tooltip</code> will displayed only value horizontally.</p>\n"},"encode":{"type":["Object"],"description":"<p>Define what is encoded to for each dimension of <code class=\"codespan\">data</code>. For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // Each column is called a dimension.\n            // There are five dimensions: 0, 1, 2, 3, 4.\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        encode: {\n            x: [3, 1, 5],      // Dimension 3, 1, 5 is mapped to x axis.\n            y: 2,              // Dimension 2 is mapped to y axis.\n            tooltip: [3, 2, 4] // Dimension 3, 2, 4 will be displayed in tooltip.\n        }\n    }\n}\n</code></pre>\n<p>When <a href=\"#series.dimensions\">dimensions</a> is used to defined name for a certain dimension, <code class=\"codespan\">encode</code> can refer the name directly. For example:</p>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;],\n    encode: {\n        x: &#39;date&#39;,\n        y: [&#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<p>The basic structure of <a href=\"option.html#series.encode\" target=\"_blank\">encode</a> is illustrated as follows, where the left part of colon is the name of axis like <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code> or some special reserved names like &quot;tooltip&quot;, &quot;itemName&quot; etc., and the right part of the colon is the dimension names or dimension indices (based on 0). One or more dimensions can be specified. Usually not all of mappings need to be specified, only specify needed ones.</p>\n<p>The properties available in <code class=\"codespan\">encode</code> listed as follows:</p>\n<pre><code class=\"lang-js\">// In any of the series and coordinate systems,\n// these properties are available:\nencode: {\n    // Display dimension &quot;product&quot; and &quot;score&quot; in the tooltip.\n    tooltip: [&#39;product&#39;, &#39;score&#39;]\n    // Set the series name as the concat of the names of dimensions[1] and dimensions[3].\n    // (sometimes the dimension names are too long to type in series.name manually).\n    seriesName: [1, 3],\n    // Using dimensions[2] as the id of each data item. This is useful when dynamically\n    // update data by `chart.setOption()`, where the new and old data item can be\n    // corresponded by id, by which the appropriate animation can be performed when updating.\n    itemId: 2,\n    // Using dimensions[3] as the name of each data item. This is useful in charts like\n    // &#39;pie&#39;, &#39;funnel&#39;, where data item name can be displayed in legend.\n    itemName: 3\n}\n\n// These properties only work in cartesian(grid) coordinate system:\nencode: {\n    // Map dimensions[1], dimensions[5] and dimension &quot;score&quot; to the X axis.\n    x: [1, 5, &#39;score&#39;],\n    // Map dimensions[0] to the Y axis.\n    y: 0\n}\n\n// These properties only work in polar coordinate system:\nencode: {\n    radius: 3,\n    angle: 2,\n    ...\n}\n\n// These properties only work in geo coordinate system:\nencode: {\n    lng: 3,\n    lat: 2\n}\n\n// For some type of series that are not in any coordinate system,\n// like &#39;pie&#39;, &#39;funnel&#39; etc.:\nencode: {\n    value: 3\n}\n</code></pre>\n<p>This is an <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=dataset-encode1&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> for <code class=\"codespan\">encode</code>.</p>\n<p>Specially, in [custom series(~series-custom), some property in <code class=\"codespan\">encode</code>, corresponding to axis, can be set as null to make the series not controlled by the axis, that is, the series data will not be count in the extent of the axis, and the <a href=\"#dataZoom\">dataZoom</a> on the axis will not filter the series.</p>\n<pre><code class=\"lang-js\">var option = {\n    xAxis: {},\n    yAxis: {},\n    dataZoom: [{\n        xAxisIndex: 0\n    }, {\n        yAxisIndex: 0\n    }],\n    series: {\n        type: &#39;custom&#39;,\n        renderItem: function (params, api) {\n            return {\n                type: &#39;circle&#39;,\n                shape: {\n                    cx: 100, // x position is always 100\n                    cy: api.coord([0, api.value(0)])[1],\n                    r: 30\n                },\n                style: {\n                    fill: &#39;blue&#39;\n                }\n            };\n        },\n        encode: {\n            // Then the series will not be controlled\n            // by x axis and corresponding dataZoom.\n            x: -1,\n            y: 1\n        },\n        data: [ ... ]\n    }\n};\n</code></pre>\n"},"data":{"type":["Array"],"description":"<p>Data array of series, which can be in the following forms:</p>\n<p>Notice, if no <code class=\"codespan\">data</code> specified in series, and there is <a href=\"#dataset\">dataset</a> in option, series will use the first <a href=\"#dataset\">dataset</a> as its datasource. If <code class=\"codespan\">data</code> has been specified, <a href=\"#dataset\">dataset</a> will not used.</p>\n<p><code class=\"codespan\">series.datasetIndex</code> can be used to specify other <a href=\"#dataset\">dataset</a>.</p>\n<p>Basically, data is represented by a two-dimension array, like the example below, where each column is named as a &quot;dimension&quot;.</p>\n<pre><code class=\"lang-js\">series: [{\n    data: [\n        // dimX   dimY   other dimensions ...\n        [  3.4,    4.5,   15,   43],\n        [  4.2,    2.3,   20,   91],\n        [  10.8,   9.5,   30,   18],\n        [  7.2,    8.8,   18,   57]\n    ]\n}]\n</code></pre>\n<ul>\n<li>In <a href=\"#grid\">cartesian (grid)</a>, &quot;dimX&quot; and &quot;dimY&quot; correspond to <a href=\"#xAxis\">xAxis</a> and <a href=\"#yAxis\">yAxis</a> respectively.</li>\n<li>In <a href=\"#polar\">polar</a> &quot;dimX&quot; and &quot;dimY&quot; correspond to <a href=\"#radiusAxis\">radiusAxis</a> 和 <a href=\"#anbleAxis\">angleAxis</a> respectively.</li>\n<li>Other dimensions are optional, which can be used in other places. For example:<ul>\n<li><a href=\"#visualMap\">visualMap</a> can map one or more dimensions to visual (color, symbol size ...).</li>\n<li><a href=\"#series.symbolSize\">series.symbolSize</a> can be set as a callback function, where symbol size can be calculated by values of a certain dimension.</li>\n<li>Values in other dimensions can be shown by <a href=\"#tooltip.formatter\">tooltip.formatter</a> or <a href=\"#series.label.formatter\">series.label.formatter</a>.</li>\n</ul>\n</li>\n</ul>\n<p>Especially, when there is one and only one category axis (axis.type is <code class=\"codespan\">&#39;category&#39;</code>), data can be simply be represented by a one-dimension array, like:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    data: [&#39;a&#39;, &#39;b&#39;, &#39;m&#39;, &#39;n&#39;]\n},\nseries: [{\n    // Each item corresponds to each item in xAxis.data.\n    data: [23,  44,  55,  19]\n    // In fact, it is the simplification of the format below:\n    // data: [[0, 23], [1, 44], [2, 55], [3, 19]]\n}]\n</code></pre>\n<p><br>\n<strong>Relationship between &quot;value&quot; and <a href=\"#xAxis.type\">axis.type</a></strong></p>\n<ul>\n<li><p>When a dimension corresponds to a value axis (axis.type is <code class=\"codespan\">&#39;value&#39;</code> or <code class=\"codespan\">&#39;log&#39;</code>):</p>\n<p>  The value can be a <code class=\"codespan\">number</code> (like <code class=\"codespan\">12</code>) (can also be a number in a <code class=\"codespan\">string</code> format, like <code class=\"codespan\">&#39;12&#39;</code>).</p>\n</li>\n<li><p>When a dimension corresponds to a category axis (axis.type is <code class=\"codespan\">&#39;category&#39;</code>):</p>\n<p>  The value should be the ordinal of the axis.data (based on <code class=\"codespan\">0</code>), the string value of the axis.data. For example:</p>\n<pre><code class=\"lang-js\">  xAxis: {\n      type: &#39;category&#39;,\n      data: [&#39;Monday&#39;, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;]\n  },\n  yAxis: {\n      type: &#39;category&#39;,\n      data: [&#39;a&#39;, &#39;b&#39;, &#39;m&#39;, &#39;n&#39;, &#39;p&#39;, &#39;q&#39;]\n  },\n  series: [{\n      data: [\n          // xAxis      yAxis\n          [  0,           0,    2  ], // This point is located at xAxis: &#39;Monday&#39;, yAxis: &#39;a&#39;.\n          [  &#39;Thursday&#39;,  2,    1  ], // This point is located at xAxis: &#39;Thursday&#39;, yAxis: &#39;m&#39;.\n          [  2,          &#39;p&#39;,   2  ], // This point is located at xAxis: &#39;Wednesday&#39;, yAxis: &#39;p&#39;.\n          [  3,           3,    5  ]\n      ]\n  }]\n</code></pre>\n<p>  There is an example of double category axes: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-punchCard\" target=\"_blank\">Github Punchcard</a>.</p>\n</li>\n<li><p>When a dimension corresponds to a time axis (type is <code class=\"codespan\">&#39;time&#39;</code>), the value can be:</p>\n<ul>\n<li>a timestamp, like <code class=\"codespan\">1484141700832</code>, which represents a UTC time.</li>\n<li>a date string, in one of the formats below:<ul>\n<li>a subset of <a href=\"http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15\" target=\"_blank\">ISO 8601</a>, only including (all of these are treated as local time unless timezone is specified, which is consistent with <a href=\"https://momentjs.com/\" target=\"_blank\">moment</a>):<ul>\n<li>only part of year/month/date/time are specified: <code class=\"codespan\">&#39;2012-03&#39;</code>, <code class=\"codespan\">&#39;2012-03-01&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 05&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 05:06&#39;</code>.</li>\n<li>separated by <code class=\"codespan\">&quot;T&quot;</code> or a space: <code class=\"codespan\">&#39;2012-03-01T12:22:33.123&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 12:22:33.123&#39;</code>.</li>\n<li>timezone specified: <code class=\"codespan\">&#39;2012-03-01T12:22:33Z&#39;</code>, <code class=\"codespan\">&#39;2012-03-01T12:22:33+8000&#39;</code>, <code class=\"codespan\">&#39;2012-03-01T12:22:33-05:00&#39;</code>.</li>\n</ul>\n</li>\n<li>other date string format (all of these are treated as local time):\n<code class=\"codespan\">&#39;2012&#39;</code>, <code class=\"codespan\">&#39;2012-3-1&#39;</code>, <code class=\"codespan\">&#39;2012/3/1&#39;</code>, <code class=\"codespan\">&#39;2012/03/01&#39;</code>,\n<code class=\"codespan\">&#39;2009/6/12 2:00&#39;</code>, <code class=\"codespan\">&#39;2009/6/12 2:05:08&#39;</code>, <code class=\"codespan\">&#39;2009/6/12 2:05:08.123&#39;</code>.</li>\n</ul>\n</li>\n<li>a JavaScript Date instance created by user:<ul>\n<li>Caution, when using a data string to create a Date instance, <a href=\"http://dygraphs.com/date-formats.html\" target=\"_blank\">browser differences and inconsistencies</a> should be considered.</li>\n<li>For example: In chrome, <code class=\"codespan\">new Date(&#39;2012-01-01&#39;)</code> is treated as a Jan 1st 2012 in UTC, while <code class=\"codespan\">new Date(&#39;2012-1-1&#39;)</code> and <code class=\"codespan\">new Date(&#39;2012/01/01&#39;)</code> are treated as Jan 1st 2012 in local timezone. In safari <code class=\"codespan\">new Date(&#39;2012-1-1&#39;)</code> is not supported.</li>\n<li>So if you intent to perform <code class=\"codespan\">new Date(dateString)</code>, it is strongly recommended to use a time parse library (e.g., <a href=\"https://momentjs.com/\" target=\"_blank\">moment</a>), or use <code class=\"codespan\">echarts.number.parseDate</code>, or check <a href=\"http://dygraphs.com/date-formats.html\" target=\"_blank\">this</a>.</li>\n</ul>\n</li>\n</ul>\n</li>\n</ul>\n<p><br>\n<strong>Customize a data item:</strong></p>\n<p>When needing to customize a data item, it can be set as an object, where property <code class=\"codespan\">value</code> reprensent real value. For example:</p>\n<pre><code class=\"lang-js\">[\n    12,\n    24,\n    {\n        value: [24, 32],\n        // label style, only works in this data item.\n        label: {},\n        // item style, only works in this data item.\n        itemStyle:{}\n    },\n    33\n]\n// Or\n[\n    [12, 332],\n    [24, 32],\n    {\n        value: [24, 32],\n        // label style, only works in this data item.\n        label: {},\n        // item style, only works in this data item.\n        itemStyle:{}\n    },\n    [33, 31]\n]\n</code></pre>\n<p><br>\n<strong>Empty value:</strong></p>\n<p><code class=\"codespan\">&#39;-&#39;</code> or <code class=\"codespan\">null</code> or <code class=\"codespan\">undefined</code> or <code class=\"codespan\">NaN</code> can be used to describe that a data item does not exist (ps：<em>not exist</em> does not means its value is <code class=\"codespan\">0</code>).</p>\n<p>For example, line chart can break when encounter an empty value, and scatter chart do not display graphic elements for empty values.</p>\n<p><br><br></p>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>The name of data item.</p>\n"},"value":{"type":["number"],"description":"<p>The value of a single data item.</p>\n"},"symbol":{"type":["string"],"description":"<p>Specify the type of graphic elements.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>Example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-graphicType&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbol\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbol\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbol: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbol: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbol: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","default":"'circle'"},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>Symbol size.</p>\n<p>It can be set as a array, which means [width, height]. For example, <code class=\"codespan\">[20, 10]</code> means width <code class=\"codespan\">20</code> and height <code class=\"codespan\">10</code>. It can also be set as a single number, like <code class=\"codespan\">10</code>, which is equivalent to <code class=\"codespan\">[10, 10]</code>.</p>\n<p>Absolute value can be used (like <code class=\"codespan\">10</code>), or percent value can be used (like <code class=\"codespan\">&#39;120%&#39;</code>, <code class=\"codespan\">[&#39;55%&#39;, 23]</code>).</p>\n<p>When percent value is used, final size of the graphic element is calculated based on its <a href=\"#series-pictorialBar\">reference bar</a>.</p>\n<p>For example, there is a reference bar based on x axis (that is, it is a vertical bar), and <a href=\"#series-pictorialBar.symbolSize\">symbolSize</a> is set as <code class=\"codespan\">[&#39;30%&#39;, &#39;50%&#39;]</code>, the final size of its graphic elements is:</p>\n<ul>\n<li>width: <code class=\"codespan\">&lt;width of reference bar&gt; * 30%</code>.</li>\n<li>height:<ul>\n<li>If <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is used: <code class=\"codespan\">&lt;height of reference bar&gt; * 50%</code>.</li>\n<li>If <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is not used: <code class=\"codespan\">&lt;height of reference bar&gt; * 50%</code>.</li>\n</ul>\n</li>\n</ul>\n<p>Analogously, the case that based on y axis can be obtained by exchanging them.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-symbolSize&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolSize\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolSize\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolSize: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolSize: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolSize: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"percent","default":"100%,100%","dims":"W,H"},"default":"['100%', '100%']"},"symbolPosition":{"type":["string"],"description":"\n\n<p>Specify the location of the graphic elements. Optional values:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code>: The edge of graphic element inscribes with the start of the reference bar.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code>: The edge of graphic element inscribes with the end of the reference bar.</li>\n<li><code class=\"codespan\">&#39;center&#39;</code>: The graphic element is at the center of the reference bar.</li>\n</ul>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-position&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolPosition\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolPosition\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolPosition: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolPosition: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolPosition: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"enum","options":"start,end,center","default":"start"},"default":"'start'"},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Specify the offset of graphic element according to its original position. Adopting <code class=\"codespan\">symbolOffset</code> is the final step in layout, which enables adjustment of graphic element position.</p>\n<p>A absolute value can be set (like <code class=\"codespan\">10</code>), or a percent value can be set (like <code class=\"codespan\">&#39;120%&#39;</code>、<code class=\"codespan\">[&#39;55%&#39;, 23]</code>), which is based on its <a href=\"#series-pictorialBar.symbolSize\">symbolSize</a>.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;-50%&#39;]</code> means the graphic element will be adjusted upward half of the size of itself.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-position&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolOffset\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolOffset\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolOffset: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolOffset: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolOffset: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"percentvector","default":"0,0","dims":"x,y"},"default":"[0, 0]"},"symbolRotate":{"type":["number"],"description":"\n\n<p>The degree of the rotation of a graphic element.</p>\n<p>Notice, <code class=\"codespan\">symbolRotate</code> will not affect the position of the graphic element, but just rotating by its center.</p>\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolRotate\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolRotate\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolRotate: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolRotate: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolRotate: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"angle","min":"-360","max":"360","step":"1"}},"symbolRepeat":{"type":["boolean","number","string"],"description":"\n\n<p>Whether to repeat a graphic element. Optional values:</p>\n<ul>\n<li><code class=\"codespan\">false</code>/<code class=\"codespan\">null</code>/<code class=\"codespan\">undefined</code>: Do not repeat, that is, each graphic element represents a data item.</li>\n<li><code class=\"codespan\">true</code>: Repeat, that is, a group of repeated graphic elements represent a data item. The repeat times is calculated according to <a href=\"#series-pictorialBar.data\">data</a>.</li>\n<li>a number: Repeat, that is a group of repeated graphic elements represent a data item. The repeat times is always the given number.</li>\n<li><code class=\"codespan\">&#39;fixed&#39;</code>: Repeat, that is a group of repeated graphic elements represent a data item. The repeat times is calcuated according to <a href=\"#series-pictorialBar.symbolBoundingData\">symbolBoundingData</a>, that is, the repeat times has nothing to do with <a href=\"#series-pictorialBar.data\">data</a>. The setting is useful when graphic elements are used as background.</li>\n</ul>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-repeat&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolRepeat\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolRepeat\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolRepeat: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolRepeat: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolRepeat: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"enum","options":"true,false,fixed"}},"symbolRepeatDirection":{"type":["string"],"description":"\n\n<p>When <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is used, <code class=\"codespan\">symbolRepeatDirection</code> specifies the render order of the repeated graphic elements. The setting is useful in these cases below:</p>\n<ul>\n<li><p>If <a href=\"#series-pictorialBar.symbolMargin\">symbolMargin</a> is set as a negative value, repeated elements will overlap with each other. <code class=\"codespan\">symbolRepeatDirection</code> can be used to specify the order of overlap.</p>\n</li>\n<li><p>If <a href=\"#series-pictorialBar.animationDelay\">animationDelay</a> or <a href=\"#series-pictorialBar.animationDelayUpdate\">animationDelayUpdate</a> is used, <code class=\"codespan\">symbolRepeatDirection</code> specifies the order of index.</p>\n</li>\n</ul>\n<p>Optional values can be <code class=\"codespan\">&#39;start&#39;</code> and <code class=\"codespan\">&#39;end&#39;</code>.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-repeatDirection&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolRepeatDirection\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolRepeatDirection\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolRepeatDirection: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolRepeatDirection: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolRepeatDirection: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"enum","options":"start,end","default":"start"},"default":"'start'"},"symbolMargin":{"type":["number","string"],"description":"\n\n<p>Specify margin of both sides of a graphic element. (&quot;both sides&quot; means the two sides in the direction of its value axis). It works only when <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is used.</p>\n<p>Absolute value can be used (like <code class=\"codespan\">20</code>), or percent value can be used (like <code class=\"codespan\">&#39;-30%&#39;</code>), which is based on its <a href=\"#series-pictorialBar.symbolSize\">symbolSize</a>.</p>\n<p><code class=\"codespan\">symbolMargin</code> can be positive value or negative value, which enables overlap of graphic elements when <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is used.</p>\n<p>A <code class=\"codespan\">&quot;!&quot;</code> can be appended on the end of the value, like <code class=\"codespan\">&quot;30%!&quot;</code> or <code class=\"codespan\">25!</code>, which means a extra blank will be added on the both ends, otherwise the graphic elements on both ends will reach the boundary by default.</p>\n<p>Notice:</p>\n<ul>\n<li>When <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is <code class=\"codespan\">true</code>/<code class=\"codespan\">&#39;fixed&#39;</code>:\n  The given <code class=\"codespan\">symbolMargin</code> is just a reference value. The final gap of graphic elements will be calculated according to <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a>, <code class=\"codespan\">symbolMargin</code> and <a href=\"#series-pictorialBar.symbolBoundingData\">symbolBoundingData</a>.</li>\n<li>When <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is set as a number:\n  <code class=\"codespan\">symbolMargin</code> does not work any more.</li>\n</ul>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-repeatLayout&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolMargin\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolMargin\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolMargin: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolMargin: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolMargin: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"percentvector","default":"0,0","dims":"x,y"}},"symbolClip":{"type":["boolean"],"description":"\n\n<p>Whether to clip graphic elements.</p>\n<ul>\n<li><code class=\"codespan\">false</code>/null/undefined: The whole graphic elements represent the size of value.</li>\n<li><code class=\"codespan\">true</code>: The clipped graphic elements reperent the size of value.</li>\n</ul>\n<p><code class=\"codespan\">symbolClip</code> is usually used in this case: both &quot;amount value&quot; and &quot;current value&quot; should be displayed. In this case, tow series can be used. One for background, using complete graphic elements, while another for current value, using clipped graphic elements.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-clip&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n<p>Notice, in the example above,</p>\n<ul>\n<li>The same <a href=\"#series.pictorialBar.symbolBoundingData\">symbolBoundingData</a> is used in &quot;background series&quot; and &quot;current value seires&quot;, which makes their graphic elements are the same size.</li>\n<li>A bigger <a href=\"#series.pictorialBar.z\">z</a> is set on &quot;current value series&quot;, which makes it is over &quot;background series&quot;.</li>\n</ul>\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolClip\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolClip\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolClip: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolClip: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolClip: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"boolean"},"default":false},"symbolBoundingData":{"type":["number"],"description":"<p>Defines a bounding area availble for the graphic elements. This setting gives a data, which will then be translated to a coordinate on the coordinate system. The coordinate specifies the bounding. Namely, if <code class=\"codespan\">symbolBoundingData</code> is set, the final size (or layout) of the graphic elements depend on the <code class=\"codespan\">symbolBoundingData</code>.</p>\n<p>When reference bar is horizontal, <code class=\"codespan\">symbolBoundingData</code> is coresponding to x axis, while reference bar is vertical, <code class=\"codespan\">symbolBoundingData</code> is coresponding to y axis.</p>\n<p>Rule:</p>\n<ul>\n<li><p>If <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is not used:</p>\n<p>  <code class=\"codespan\">symbolBoundingData</code> is the same as the size of reference bar by default. The size of the graphic element is detemined by <code class=\"codespan\">symbolBoundingData</code>. For example, if reference bar is vertical, its data is <code class=\"codespan\">24</code>, <code class=\"codespan\">symbolSize</code> is set as <code class=\"codespan\">[30, &#39;50%&#39;]</code>, <code class=\"codespan\">symbolBoundingData</code> is set as <code class=\"codespan\">124</code>, the final size of the graphic element will be <code class=\"codespan\">124 * 50% = 62</code>. If <code class=\"codespan\">symbolBoundingData</code> is not set, the final size will be <code class=\"codespan\">24 * 50% = 12</code>.</p>\n</li>\n<li><p>If <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is used:</p>\n<p>  <code class=\"codespan\">symbolBoundingData</code> is the extreme value of the coordinate system. <code class=\"codespan\">symbolBoundingData</code> defines a bounding area, where repeated graphic elements layout according to <a href=\"#series-pictorialBar.symbolMargin\">symbolMargin</a> and <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> and <a href=\"#series-pictorialBar.symbolSize\">symbolSize</a>. Both these settings determine the gap size of the repeated graphic elements.</p>\n</li>\n</ul>\n<p><code class=\"codespan\">symbolBoundingData</code> is usually used in these cases:</p>\n<ul>\n<li><p>When <a href=\"#series-pictorialBar.symbolClip\">symbolCilp</a> is used:</p>\n<p>  And a series is used to display &quot;amont value&quot;, while another series is used to display &quot;current value&quot;. <code class=\"codespan\">symbolBoundingData</code> can be used to ensure that the graphic elements of these two series are at the same size.</p>\n</li>\n</ul>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-clip&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n<ul>\n<li><p>When <a href=\"#series-pictorialBar.symbolRepeat\">symbolRepeat</a> is used:</p>\n<p>  <code class=\"codespan\">symbolBoundingData</code> can be use to ensure the gaps of the elements in different bars are the same. Of cource, you can do not set <code class=\"codespan\">symbolBoundingData</code>, whose default value is a stable value (extreme value of the coordinate system).</p>\n</li>\n</ul>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-repeatLayout&reset=1&edit=1\" width=\"800\" height=\"600\"></iframe>\n\n\n<p><br>\n<code class=\"codespan\">symbolBoundingData</code> can also be an array, such as <code class=\"codespan\">[-40, 60]</code>, which specifies both negative and positive symbolBoundingData.</p>\n<p>Check this example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-symbolBoundingDataArray&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolBoundingData\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolBoundingData\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolBoundingData: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolBoundingData: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolBoundingData: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n"},"symbolPatternSize":{"type":["number"],"description":"\n\n<p>Image can be used as the pattern of graphic elements.</p>\n<pre><code class=\"lang-js\">var textureImg = new Image();\ntextureImg.src = &#39;data:image/jpeg;base64,...&#39;; // dataURI\n// Or\n// textureImg.src = &#39;http://xxx.xxx.xxx/xx.png&#39;; // URL\n...\nitemStyle: {\n    color: {\n        image: textureImg,\n        repeat: &#39;repeat&#39;\n    }\n}\n</code></pre>\n<p><code class=\"codespan\">symbolPatternSize</code> specifies the size of pattern image. For example, if <code class=\"codespan\">symbolPatternSize</code> is <code class=\"codespan\">400</code>, the pattern image will be displayed at the size of <code class=\"codespan\">400px * 400px</code>.</p>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-patternSize&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.symbolPatternSize\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.symbolPatternSize\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    symbolPatternSize: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        symbolPatternSize: ... // Only affect this data item.\n    }, {\n        value: 56\n        symbolPatternSize: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"number","default":"400","step":"10","min":"0"},"default":400},"z":{"type":["number"],"description":"<p>Specify the relationship of overlap between graphic elements. A bigger value means higher.</p>\n"},"hoverAnimation":{"type":["boolean"],"description":"\n\n<p>Whether to enable hover animation.</p>\n<p>This attribute can be set at the <a href=\"#series-pictorialBar.hoverAnimation\">root level of a series</a>, where all data items in the series will be affected by this attribute. And this attribute can also be set at <a href=\"#series-pictorialBar.data.hoverAnimation\">each data item</a> in <a href=\"series-pictorialBar.data\" target=\"_blank\">series-pictorialBar.data</a>, where only the data item is affected by this attribute.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: [{\n    hoverAnimation: ... // Affect all data items.\n    data: [23, 56]\n}]\n// Or\nseries: [{\n    data: [{\n        value: 23\n        hoverAnimation: ... // Only affect this data item.\n    }, {\n        value: 56\n        hoverAnimation: ... // Only affect this data item.\n    }]\n}]\n</code></pre>\n","uiControl":{"type":"boolean"},"default":false},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Specify the delay time before animation start. Callback function can be used, where different delay time can be used on different element.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (dataIndex, params) {\n    return params.index * 30;\n}\n// Or inverse:\nanimationDelay: function (dataIndex, params) {\n    return (params.count - 1 - params.index) * 30;\n}\n</code></pre>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-repeatDirection&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n","default":0},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Specify the delay time before update animation. Callback function can be used, where different delay time can be used on different element.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (dataIndex, params) {\n    return params.index * 30;\n}\n// Or inverse:\nanimationDelay: function (dataIndex, params) {\n    return (params.count - 1 - params.index) * 30;\n}\n</code></pre>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-repeatDirection&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n\n\n\n\n\n\n","default":0},"label":{"type":["Object"],"description":"<p>The style setting of the text label in a single bar.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"inside"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of the specified single data.</p>\n","properties":{"label":{"type":["Object"],"description":"<p>Label style configurations of single data.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Rectangle style configurations of single data.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Bar color. </p>\n","uiControl":{"type":"color"},"default":"auto"},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color of bar.</p>\n","uiControl":{"type":"color","value":"#000"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of bar. defaults to have no border.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type. Can be <code class=\"codespan\">&#39;dashed&#39;</code>, <code class=\"codespan\">&#39;dotted&#39;</code>.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>The radius of rounded corner. Its unit is px. And it supports use array to respectively specify the 4 corner radiuses.</p>\n<p>For example:</p>\n<pre><code>borderRadius: 5, // consistently set the size of 4 rounded corners\nborderRadius: [5, 5, 0, 0] // (clockwise upper left, upper right, bottom right and bottom left)\n</code></pre>","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"},"default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state of the specified single data.</p>\n","properties":{"label":{"type":["Object"],"description":"<p>Label style configurations of single data.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Rectangle style configurations of single data.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Bar color. </p>\n","uiControl":{"type":"color"},"default":"auto"},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color of bar.</p>\n","uiControl":{"type":"color","value":"#000"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of bar. defaults to have no border.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type. Can be <code class=\"codespan\">&#39;dashed&#39;</code>, <code class=\"codespan\">&#39;dotted&#39;</code>.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>The radius of rounded corner. Its unit is px. And it supports use array to respectively specify the 4 corner radiuses.</p>\n<p>For example:</p>\n<pre><code>borderRadius: 5, // consistently set the size of 4 rounded corners\nborderRadius: [5, 5, 0, 0] // (clockwise upper left, upper right, bottom right and bottom left)\n</code></pre>","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"},"default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state of the specified single data.</p>\n","properties":{"label":{"type":["Object"],"description":"<p>Label style configurations of single data.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Rectangle style configurations of single data.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Bar color. </p>\n","uiControl":{"type":"color"},"default":"auto"},"borderColor":{"type":["Color"],"description":"\n\n<p>The border color of bar.</p>\n","uiControl":{"type":"color","value":"#000"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p>The border width of bar. defaults to have no border.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type. Can be <code class=\"codespan\">&#39;dashed&#39;</code>, <code class=\"codespan\">&#39;dotted&#39;</code>.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"borderRadius":{"type":["number","Array"],"description":"\n\n<p>The radius of rounded corner. Its unit is px. And it supports use array to respectively specify the 4 corner radiuses.</p>\n<p>For example:</p>\n<pre><code>borderRadius: 5, // consistently set the size of 4 rounded corners\nborderRadius: [5, 5, 0, 0] // (clockwise upper left, upper right, bottom right and bottom left)\n</code></pre>","uiControl":{"type":"vector","min":"0","dims":"LT,RT,RB,LB"},"default":0},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series data.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}}},"markPoint":{"type":["Object"],"description":"<p>Mark point in a chart.</p>\n","properties":{"symbol":{"type":["string","Function"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre><p>If symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-pictorialBar.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"icon","default":"circle"},"default":"'pin'"},"symbolSize":{"type":["number","Array","Function"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n<p>If size of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number|Array\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-pictorialBar.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n","uiControl":{"type":"number","min":"0"},"default":50},"symbolRotate":{"type":["number","Function"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n<p>If rotation of symbols needs to be different, you can set with callback function in the following format:</p>\n<pre><code class=\"lang-js\">(value: Array|number, params: Object) =&gt; number\n</code></pre>\n<p>The first parameter <code class=\"codespan\">value</code> is the value in <a href=\"#series-pictorialBar.data\">data</a>, and the second parameter <code class=\"codespan\">params</code> is the rest parameters of data item.</p>\n<blockquote>\n<p>Callback is supported since 4.8.0 .</p>\n</blockquote>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label of mark point.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'inside'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark point.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {@score}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["Array"],"description":"<p>Data array for mark points, each of which is an object. Here are some ways to assign mark point position.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-pictorialBar.markPoint.data.x\">x</a>, <a href=\"#series-pictorialBar.markPoint.data.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li><p>Assign coordinate position with <a href=\"#series-pictorialBar.markPoint.data.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</p>\n</li>\n<li><p>Use <a href=\"#series-pictorialBar.markPoint.data.type\">type</a> attribute to mark the maximum and minimum values in the series, in which <a href=\"#series-pictorialBar.markPoint.data.valueIndex\">valueIndex</a> or <a href=\"#series-pictorialBar.markPoint.data.valueDim\">valueDim</a> can be used to assign the dimension.</p>\n</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p><strong>For example: </strong></p>\n<pre><code class=\"lang-js\">data: [\n    {\n        name: &#39;maximum&#39;,\n        type: &#39;max&#39;\n    }, \n    {\n        name: &#39;coordinate&#39;,\n        coord: [10, 20]\n    }, {\n        name: &#39;fixed x position&#39;,\n        yAxis: 10,\n        x: &#39;90%&#39;\n    }, \n\n    {\n        name: &#39;screen coordinate&#39;,\n        x: 100,\n        y: 100\n    }\n]\n</code></pre>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Mark point name.</p>\n","default":"''"},"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Available when using <a href=\"#series-pictorialBar.markPoint.data.type\">type</a> it is used to assign maximum value and minimum value in dimensions, it could be <code class=\"codespan\">0</code> (xAxis, radiusAxis), <code class=\"codespan\">1</code> (yAxis, angleAxis), and use the first value axis dimension by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-pictorialBar.markPoint.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of .</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p> symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of  symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of  symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"itemStyle":{"type":["Object"],"description":"<p>Mark point style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markLine":{"type":["Object"],"description":"<p>Use a line in the chart to illustrate.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"symbol":{"type":["string","Array"],"description":"<p>Symbol type at the two ends of the mark line. It can be an array for two ends, or assigned seperately. See <a href=\"#series-pictorialBar.markLine.data.0.symbol\">data.symbol</a> for more format information.</p>\n"},"symbolSize":{"type":["number","Array"],"description":"<p>Symbol size at the two ends of the mark line. It can be an array for two ends, or assigned seperately.</p>\n<p><strong>Attention: </strong> You cannot assgin width and height seperately as normal <code class=\"codespan\">symbolSize</code>.</p>\n"},"precision":{"type":["number"],"description":"<p>Precision of marking line value, which is useful when displaying average value mark line.</p>\n","default":2},"label":{"type":["Object"],"description":"<p>Mark line text.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"<p>Mark line style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark line.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>Data array of marking line. Every array item can be an array of one or two values, representing starting and ending point of the line, and every item is an object. Here are several ways to assign the positions of starting and ending point.</p>\n<ol>\n<li>Assign coordinate according to container with <a href=\"#series-pictorialBar.markLine.data.0.x\">x</a>, <a href=\"#series-pictorialBar.markLine.data.0.y\">y</a> attribute, in which pixel values and percentage are supported.</li>\n</ol>\n<ol start=\"2\">\n<li><p>Assign coordinate position with <a href=\"#series-pictorialBar.markLine.data.0.coord\">coord</a> attribute, in which <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> are supported for each dimension.</p>\n</li>\n<li><p>Use <a href=\"#series-pictorialBar.markLine.data.0.type\">type</a> attribute to mark the maximum and minimum values in the series, in which <a href=\"#series-pictorialBar.markLine.data.0.valueIndex\">valueIndex</a> or <a href=\"#series-pictorialBar.markLine.data.0.valueDim\">valueDim</a> can be used to assign the dimension.</p>\n</li>\n<li><p>You may also create a mark line in Cartesian coordinate at a specific position in X or Y axis by assigning <code class=\"codespan\">xAxis</code> or <code class=\"codespan\">yAxis</code>. See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-weight\" target=\"_blank\">scatter-weight</a> for example.</p>\n</li>\n</ol>\n<p>When multiple attributes exist, priority is as the above order.</p>\n<p>You may also set the type of mark line through <code class=\"codespan\">type</code>, stating whether it is for the maximum value or average value. Likewise, dimensions can be assigned through <code class=\"codespan\">valueIndex</code>.</p>\n<pre><code>data: [\n\n{\n        name: &#39;average line&#39;,\n        // &#39;average&#39;, &#39;min&#39;, and &#39;max&#39; are supported\n        type: &#39;average&#39;\n    },\n    {\n        name: &#39;Horizontal line with Y value at 100&#39;,\n        yAxis: 100\n    },\n    [\n        {\n            // Use the same name with starting and ending point\n            name: &#39;Minimum to Maximum&#39;,\n            type: &#39;min&#39;\n        },\n        {\n            type: &#39;max&#39;\n        }\n    ],\n[\n        {\n            name: &#39;Markline between two points&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [{\n        // Mark line with a fixed X position in starting point. This is used to generate an arrow pointing to maximum line.\n        yAxis: &#39;max&#39;,\n        x: &#39;90%&#39;\n    }, {\n        type: &#39;max&#39;\n    }],\n[\n        {\n            name: &#39;Mark line between two points&#39;,\n            x: 100,\n            y: 100\n        },\n        {\n            x: 500,\n            y: 200\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Data of the starting point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n<li><code class=\"codespan\">&#39;median&#39;</code> median value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-pictorialBar.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-pictorialBar.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'starting point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of starting point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>starting point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of starting point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of starting point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Data of the ending point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Special label types, are used to label maximum value, minimum value and so on.</p>\n<p><strong>Options are:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> minimum value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> maximum value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n<li><code class=\"codespan\">&#39;median&#39;</code> median value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Works only when <a href=\"#series-pictorialBar.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be <code class=\"codespan\">0</code> (for xAxis, or radiusAxis), or <code class=\"codespan\">1</code> (for yAxis, or angleAxis). Dimension of the first numeric axis is used by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Works only when <a href=\"#series-pictorialBar.markLine.data.type\">type</a> is assigned. It is used to state the dimension used to calculate maximum value or minimum value. It may be the direct name of a dimension, like <code class=\"codespan\">x</code>, or <code class=\"codespan\">angle</code> for line charts, or <code class=\"codespan\">open</code>, or <code class=\"codespan\">close</code> for candlestick charts.</p>\n"},"coord":{"type":["Array"],"description":"<p>Coordinates of the starting point or ending point, whose format depends on the coordinate of the series. It can be <code class=\"codespan\">x</code>, and <code class=\"codespan\">y</code> for <a href=\"#grid\">rectangular coordinates</a>, or <code class=\"codespan\">radius</code>, and <code class=\"codespan\">angle</code> for <a href=\"#polar\">polar coordinates</a>.</p>\n<p><strong>Notice:</strong> For axis with <a href=\"#xAixs.type\">axis.type</a> <code class=\"codespan\">&#39;category&#39;</code>:</p>\n<ul>\n<li>If coord value is <code class=\"codespan\">number</code>, it represents index of <a href=\"#xAxis.data\">axis.data</a>.</li>\n<li>If coord value is <code class=\"codespan\">string</code>, it represents concrete value in <a href=\"#xAxis.data\">axis.data</a>. Please notice that in this case <code class=\"codespan\">xAxis.data</code> must not be written as [number, number, ...], but can only be written [string, string, ...]. Otherwise it is not able to be located by markPoint / markLine.</li>\n</ul>\n<p>For example:</p>\n<pre><code class=\"lang-javascript\">{\n    xAxis: {\n        type: &#39;category&#39;,\n        data: [&#39;5&#39;, &#39;6&#39;, &#39;9&#39;, &#39;13&#39;, &#39;19&#39;, &#39;33&#39;]\n        // As mentioned above, data should not be [5, 6, 9, 13, 19, 33] here.\n    },\n    series: {\n        type: &#39;line&#39;,\n        data: [11, 22, 33, 44, 55, 66],\n        markPoint: { // markLine is in the same way.\n            data: [{\n                coord: [5, 33.4], // The number 5 represents xAxis.data[5], that is, &#39;33&#39;.\n                // coord: [&#39;5&#39;, 33.4] // The string &#39;5&#39; represents the &#39;5&#39; in xAxis.data.\n            }]\n        }\n    }\n}\n</code></pre>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'ending point'"},"x":{"type":["number"],"description":"\n\n<p>X position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>Y position according to container, in pixel.</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>Label value, which can be ignored.</p>\n"},"symbol":{"type":["string"],"description":"\n\n<p>Symbol of ending point.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>","uiControl":{"type":"icon","default":"circle"}},"symbolSize":{"type":["number","Array"],"description":"\n\n<p>ending point symbol size. It can be set to single numbers like <code class=\"codespan\">10</code>, or use an array to represent width and height. For example, <code class=\"codespan\">[20, 10]</code> means symbol width is <code class=\"codespan\">20</code>, and height is<code class=\"codespan\">10</code>.</p>\n","uiControl":{"type":"number","min":"0"}},"symbolRotate":{"type":["number"],"description":"\n\n<p>Rotate degree of ending point symbol. The negative value represents clockwise. Note that when <code class=\"codespan\">symbol</code> is set to be <code class=\"codespan\">&#39;arrow&#39;</code> in <code class=\"codespan\">markLine</code>, <code class=\"codespan\">symbolRotate</code> value will be ignored, and compulsively use tangent angle.</p>\n","uiControl":{"type":"angle","min":"-180","max":"180","step":"1"}},"symbolKeepAspect":{"type":["boolean"],"description":"\n\n<p>Whether to keep aspect for symbols in the form of <code class=\"codespan\">path://</code>.</p>\n","uiControl":{"type":"boolean","clean":"true"},"default":false},"symbolOffset":{"type":["Array"],"description":"\n\n<p>Offset of ending point symbol relative to original position. By default, symbol will be put in the center position of data. But if symbol is from user-defined vector path or image, you may not expect symbol to be in center. In this case, you may use this attribute to set offset to default position. It can be in absolute pixel value, or in relative percentage value.</p>\n<p>For example, <code class=\"codespan\">[0, &#39;50%&#39;]</code> means to move upside side position of symbol height. It can be used to make the arrow in the bottom to be at data position when symbol is pin.</p>\n","uiControl":{"type":"vector","separate":"true","dims":"x,y"},"default":"[0, 0]"},"lineStyle":{"type":["Object"],"description":"<p>Line style of this data item, which will be merged with <code class=\"codespan\">lineStyle</code> of starting point and ending point.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"<p>Label of this data item, which will be merged with <code class=\"codespan\">label</code> of starting point and ending point.</p>\n","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"curveness":{"type":["number"],"description":"\n\n<p>Edge curvature, which supports value from 0 to 1. The larger the value, the greater the curvature.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"0.01","default":"0"},"default":0}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"<p>Whether show label or not.</p>\n","default":true},"position":{"type":["string"],"description":"<p>Positions of labels can be:</p>\n<ul>\n<li><code class=\"codespan\">&#39;start&#39;</code> starting point of the line.</li>\n<li><code class=\"codespan\">&#39;middle&#39;</code> middle point of the line.</li>\n<li><code class=\"codespan\">&#39;end&#39;</code> ending point of the line.</li>\n</ul>\n<p>Since version 4.7.0, more label positions are supported: <code class=\"codespan\">&#39;start&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;end&#39;</code>, <code class=\"codespan\">&#39;insideStartTop&#39;</code>, <code class=\"codespan\">&#39;insideStartBottom&#39;</code>, <code class=\"codespan\">&#39;insideMiddleTop&#39;</code>, <code class=\"codespan\">&#39;insideMiddleBottom&#39;</code>, <code class=\"codespan\">&#39;insideEndTop&#39;</code>, <code class=\"codespan\">&#39;insideEndBottom&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;insideMiddleBottom&#39;</code> is the same as <code class=\"codespan\">&#39;middle&#39;</code>. Position is as the following chart.</p>\n<p>The distance between labels and mark lines can be set with <a href=\"#series-.markLine.label.distance\">label.distance</a>.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-markline&reset=1&edit=1\" width=\"800\" height=\"500\"></iframe>\n\n","default":"'end'"},"distance":{"type":["number","Array"],"description":"<p>The distance between labels and mark lines. If it&#39;s an array, then the first element is the horizontal distance, and the second element is the vertical distance. If it&#39;s a number, then the horizontal and vertical distances are the same.</p>\n"},"formatter":{"type":["string","Function"],"description":"<p>Data label formatter, which supports string template and callback function. In either form, <code class=\"codespan\">\\n</code> is supported to represent a new line.</p>\n<p><strong>String template</strong></p>\n<p>Model variation includes:</p>\n<ul>\n<li><code class=\"codespan\">{a}</code>: series name.</li>\n<li><code class=\"codespan\">{b}</code>: the name of a data item.</li>\n<li><code class=\"codespan\">{c}</code>: the value of a data item.</li>\n<li><code class=\"codespan\">{d}</code>: the percent.</li>\n<li><code class=\"codespan\">{@xxx}: the value of a dimension named</code>&#39;xxx&#39;<code class=\"codespan\">, for example,</code>{@product}<code class=\"codespan\">refers the value of</code>&#39;product&#39;` dimension.</li>\n<li><code class=\"codespan\">{@[n]}: the value of a dimension at the index of</code>n<code class=\"codespan\">, for example,</code>{@[3]}` refers the value at dimensions[3].</li>\n</ul>\n<p><strong>example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b}: {d}&#39;\n</code></pre>\n<p><strong>Callback function</strong></p>\n<p>Callback function is in form of:</p>\n<pre><code class=\"lang-js\">(params: Object|Array) =&gt; string\n</code></pre>\n<p>where <code class=\"codespan\">params</code> is the single dataset needed by formatter, which is formed as:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n"},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"markArea":{"type":["Object"],"description":"<p>Used to mark an area in chart. For example, mark a time interval.</p>\n","properties":{"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"label":{"type":["Object"],"description":"<p>Label in mark area.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Style of the mark area.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis status of mark area.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state. Whether to blur follows the series.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"itemStyle":{"type":["*"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"data":{"type":["*"],"description":"<p>The scope of the area is defined by <code class=\"codespan\">data</code>, which is an array with two item, representing the left-top point and the right-bottom point of rectangle area. Each item can be defined as follows:</p>\n<ol>\n<li>Specify the coordinate in screen coordinate system using <a href=\"#series-pictorialBar.markArea.data.0.x\">x</a>, <a href=\"#series-pictorialBar.markArea.data.0.y\">y</a>, where the unit is pixel (e.g., the value is <code class=\"codespan\">5</code>), or percent (e.g., the value is <code class=\"codespan\">&#39;35%&#39;</code>).</li>\n</ol>\n<ol start=\"2\">\n<li><p>Specify the coordinate in data coordinate system (i.e., cartesian) using\n<a href=\"#series-pictorialBar.markArea.data.0.coord\">coord</a>, which can be also set as <code class=\"codespan\">&#39;min&#39;</code>, <code class=\"codespan\">&#39;max&#39;</code>, <code class=\"codespan\">&#39;average&#39;</code> (e.g, <code class=\"codespan\">coord: [23, &#39;min&#39;]</code>, or <code class=\"codespan\">coord: [&#39;average&#39;, &#39;max&#39;]</code>).</p>\n</li>\n<li><p>Locate the point on the min value or max value of <code class=\"codespan\">series.data</code> using <a href=\"#series-pictorialBar.markArea.data.0.type\">type</a>, where <a href=\"#series-pictorialBar.markArea.data.0.valueIndex\">valueIndex</a> or <a href=\"#series-pictorialBar.markPoint.data.0.valueDim\">valueDim</a> can be used to specify the dimension on which the min, max or average are calculated.</p>\n</li>\n<li>If in cartesian, you can only specify <code class=\"codespan\">xAxis</code> or <code class=\"codespan\">yAxis</code> to define a mark area based on only X or Y axis, see sample <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-weight\" target=\"_blank\">scatter-weight</a></li>\n</ol>\n<p>The priority follows as above if more than one above definition used.</p>\n<pre><code>data: [\n\n\n    [\n        {\n            name: &#39;From average to max&#39;,\n            type: &#39;average&#39;\n        },\n        {\n            type: &#39;max&#39;\n        }\n    ],\n\n    [\n        {\n            name: &#39;Mark area between two points in data coordiantes&#39;,\n            coord: [10, 20]\n        },\n        {\n            coord: [20, 30]\n        }\n    ], [\n        {\n            name: &#39;From 60 to 80&#39;,\n            yAxis: 60\n        },\n        {\n            yAxis: 80\n        }\n    ], [\n        {\n            name: &#39;Mark area covers all data&#39;\n            coord: [&#39;min&#39;, &#39;min&#39;]\n        },\n        {\n            coord: [&#39;max&#39;, &#39;max&#39;]\n        }\n    ],\n[\n        {\n            name: &#39;Mark area in two screen points&#39;,\n            x: 100,\n            y: 100\n        }, {\n            x: &#39;90%&#39;,\n            y: &#39;10%&#39;\n        }\n    ]\n]\n</code></pre>","properties":{"0":{"type":["Object"],"description":"<p>Specify the left-top point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Specify this item is on min or max or average value.</p>\n<p><strong>Options:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> max value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> min value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-pictorialBar.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-pictorialBar.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'start'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}},"1":{"type":["Object"],"description":"<p>Specify the right-bottom point.</p>\n","properties":{"type":{"type":["string"],"description":"\n\n<p>Specify this item is on min or max or average value.</p>\n<p><strong>Options:</strong></p>\n<ul>\n<li><code class=\"codespan\">&#39;min&#39;</code> max value.</li>\n<li><code class=\"codespan\">&#39;max&#39;</code> min value.</li>\n<li><code class=\"codespan\">&#39;average&#39;</code> average value.</li>\n</ul>\n","uiControl":{"type":"enum","options":"min,max,average"}},"valueIndex":{"type":["number"],"description":"\n\n<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-pictorialBar.markArea.data.type\">type</a> used.\nThe value can be <code class=\"codespan\">0</code> (means xAxis, radiusAxis) or <code class=\"codespan\">1</code> (means yAxis, angleAxis),\nusing the dimension of the first axis by default.</p>\n","uiControl":{"type":"number","min":"0","max":"1","step":"1"}},"valueDim":{"type":["string"],"description":"<p>Specify the dimension on which min, max, average are calculated,\navailable when <a href=\"#series-pictorialBar.markArea.data.type\">type</a> used.\nThe value can be the name of the dimension (for example, the value can be <code class=\"codespan\">x</code>, <code class=\"codespan\">angle</code> in line chart, and <code class=\"codespan\">open</code>, <code class=\"codespan\">close</code> in candlestick).</p>\n"},"coord":{"type":["Array"],"description":"<p>The format is [start coordinate, end coordinate], where the coordinate system can be <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code> on <a href=\"#grid\">cartesian</a>, or <code class=\"codespan\">radius</code>, <code class=\"codespan\">angle</code> on <a href=\"#polar\">polar</a>.</p>\n"},"name":{"type":["string"],"description":"<p>Name of the marker, which will display as a label.</p>\n","default":"'end'"},"x":{"type":["number"],"description":"\n\n<p>x value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"y":{"type":["number"],"description":"\n\n<p>y value on screen coordinate system, can be pixel number (like <code class=\"codespan\">5</code>), or percent value (like <code class=\"codespan\">&#39;20%&#39;</code>).</p>\n","uiControl":{"type":"percent","default":"0"}},"value":{"type":["number"],"description":"<p>value of the item, not necessary.</p>\n"},"itemStyle":{"type":["Object"],"description":"<p>Style of the item.\n<code class=\"codespan\">itemStyle</code> of start point and end point will be merged together.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"<p>Label style of the item.\nLabel style of start point and end point will be merged together.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"}},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}}}}}}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"false","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0}}},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in Pictorial bar chart .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in Pictorial bar chart , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut","properties":{"animationDelay":{"type":["number","Function"],"description":"<p>Specify the delay time before animation start. Callback function can be used, where different delay time can be used on different element.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (dataIndex, params) {\n    return params.index * 30;\n}\n// Or inverse:\nanimationDelay: function (dataIndex, params) {\n    return (params.count - 1 - params.index) * 30;\n}\n</code></pre>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-repeatDirection&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n","default":0},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Specify the delay time before update animation. Callback function can be used, where different delay time can be used on different element.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (dataIndex, params) {\n    return params.index * 30;\n}\n// Or inverse:\nanimationDelay: function (dataIndex, params) {\n    return (params.count - 1 - params.index) * 30;\n}\n</code></pre>\n<p>For example:</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/pictorialBar-repeatDirection&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n\n\n\n\n\n","default":0}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p><strong> Theme river </strong></p>\n<p>It is a special flow graph which is mainly used to present the changes of an event or theme during a period.</p>\n<p><strong>Sample: </strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=themeRiver-lastfm&edit=1&reset=1\" width=\"700\" height=\"580\"></iframe>\n\n\n\n<p><br>\n<strong>visual encoding: </strong></p>\n<p>The ribbon-shape river branches in different colors in theme river encode variable events or themes. The width of river branches encode the value of the original dataset.</p>\n<p>What&#39;s more, the time attribute of the orinigal dataset would map to a single time axis.</p>\n","properties":{"type":{"type":["string"],"description":"","default":"'themeRiver'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in .</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in , which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"left":{"type":["string","number"],"description":"<p>Distance between thmemRiver component and the left side of the container.</p>\n<p><code class=\"codespan\">left</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, or <code class=\"codespan\">&#39;right&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"5%"},"top":{"type":["string","number"],"description":"<p>Distance between thmemRiver component and the top side of the container.</p>\n<p><code class=\"codespan\">top</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>; and it can also be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>If the <code class=\"codespan\">left</code> value is set to be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, or <code class=\"codespan\">&#39;bottom&#39;</code>, then the component will be aligned automatically based on position.</p>\n","default":"5%"},"right":{"type":["string","number"],"description":"<p>Distance between thmemRiver component and the right side of the container.</p>\n<p><code class=\"codespan\">right</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":"5%"},"bottom":{"type":["string","number"],"description":"<p>Distance between thmemRiver component and the bottom side of the container.</p>\n<p><code class=\"codespan\">bottom</code> value can be instant pixel value like <code class=\"codespan\">20</code>; it can also be a percentage value relative to container width like <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n","default":"5%"},"width":{"type":["string","number"],"description":"<p>Width of thmemRiver component. </p>\n","default":null},"height":{"type":["string","number"],"description":"<p>Height of thmemRiver component. </p>\n<p><strong> Notes: </strong>\nThe positional information of the whole theme river view reuses the positional information of a single time axis, which are left, top, right and bottom.</p>\n","default":null},"coordinateSystem":{"type":["string"],"description":"<p>coordinate. The theme river adopts sinle time axis.</p>\n","default":"\"single\""},"boundaryGap":{"type":["Array"],"description":"<p>The boundary gap of the direction orthogonal with coordinate axis in diagram, which is set to adjust the diagram position, keeping it on the screen center instead of the upside or downside of the screen.</p>\n","default":"[\"10%\", \"10%\"]"},"singleAxisIndex":{"type":["number"],"description":"<p>The index of single time axis, which defaults to be 0 because it contains only one axis.</p>\n","default":0},"label":{"type":["Object"],"description":"<p><code class=\"codespan\">label</code> describes style of text labels with which each ribbon-shape river branch corresponds in theme river.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'left'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"'#000'"},"default":"'#000'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"11","min":"1","step":"1"},"default":11},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"itemStyle":{"type":["Object"],"description":"<p>style of each ribbon-shape river branch in theme river.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}},"emphasis":{"type":["Object"],"description":"<p>Configurations of emphasis state.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When the data is highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">emphasis: {\n    focus: &#39;series&#39;,\n    blurScope: &#39;coordinateSystem&#39;\n}\n</code></pre>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=bar-y-category-stack&reset=1&edit=1\" width=\"600\" height=\"400\"></iframe>\n\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'left'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"'#000'"},"default":"'#000'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"11","min":"1","step":"1"},"default":11},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of blur state.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'left'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"'#000'"},"default":"'#000'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"11","min":"1","step":"1"},"default":11},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Configurations of select state.</p>\n","properties":{"label":{"type":["Object"],"description":"","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show label.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"position":{"type":["string","Array"],"description":"\n\n\n\n<p>Label position.</p>\n<p><strong>Followings are the options: </strong></p>\n<ul>\n<li><p>[x, y]</p>\n<p>  Use relative percentage, or absolute pixel values to represent position of label relative to top-left corner of bounding box.\n  For example:</p>\n<pre><code class=\"lang-js\">  // Absolute pixel values\n  position: [10, 10],\n  // Relative percentage\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p>&#39;top&#39;</p>\n</li>\n<li>&#39;left&#39;</li>\n<li>&#39;right&#39;</li>\n<li>&#39;bottom&#39;</li>\n<li>&#39;inside&#39;</li>\n<li>&#39;insideLeft&#39;</li>\n<li>&#39;insideRight&#39;</li>\n<li>&#39;insideTop&#39;</li>\n<li>&#39;insideBottom&#39;</li>\n<li>&#39;insideTopLeft&#39;</li>\n<li>&#39;insideBottomLeft&#39;</li>\n<li>&#39;insideTopRight&#39;</li>\n<li>&#39;insideBottomRight&#39;</li>\n</ul>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"enum","options":"top,left,right,bottom,inside,insideLeft,insideRight,insideTop,insideBottom,insideTopLeft,insideBottomLeft,insideTopRight,insideBottomRight,outside"},"default":"'left'"},"distance":{"type":["number"],"description":"\n\n<p>Distance to the host graphic element.</p>\n<p>It is valid only when <code class=\"codespan\">position</code> is string value (like <code class=\"codespan\">&#39;top&#39;</code>、<code class=\"codespan\">&#39;insideRight&#39;</code>).</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/label-position\" target=\"_blank\">label position</a>.</p>\n","uiControl":{"type":"number","default":"5","min":"0","step":"0.5"},"default":5},"rotate":{"type":["number"],"description":"\n\n<p>Rotate label, from -90 degree to 90, positive value represents rotate anti-clockwise.</p>\n<p>See: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-label-rotation\" target=\"_blank\">label rotation</a>.</p>\n","uiControl":{"type":"angle","default":"0","min":"-90","max":"90","step":"1"}},"offset":{"type":["Array"],"description":"\n\n<p>Whether to move text slightly. For example: <code class=\"codespan\">[30, 40]</code> means move <code class=\"codespan\">30</code> horizontally and move <code class=\"codespan\">40</code> vertically.</p>\n","uiControl":{"type":"vector","dims":"x,y","step":"0.5","separate":"true"}},"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"'#000'"},"default":"'#000'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"11","min":"1","step":"1"},"default":11},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"},"rich":{"type":["Object"],"description":"<p>&quot;Rich text styles&quot; can be defined in this <code class=\"codespan\">rich</code> property. For example:</p>\n<pre><code class=\"lang-js\">label: {\n    // Styles defined in &#39;rich&#39; can be applied to some fragments\n    // of text by adding some markers to those fragment, like\n    // `{styleName|text content text content}`.\n    // `&#39;\\n&#39;` is the newline character.\n    formatter: [\n        &#39;{a|Style &quot;a&quot; is applied to this snippet}&#39;\n        &#39;{b|Style &quot;b&quot; is applied to this snippet}This snippet use default style{x|use style &quot;x&quot;}&#39;\n    ].join(&#39;\\n&#39;),\n\n    rich: {\n        a: {\n            color: &#39;red&#39;,\n            lineHeight: 10\n        },\n        b: {\n            backgroundColor: {\n                image: &#39;xxx/xxx.jpg&#39;\n            },\n            height: 40\n        },\n        x: {\n            fontSize: 18,\n            fontFamily: &#39;Microsoft YaHei&#39;,\n            borderColor: &#39;#449933&#39;,\n            borderRadius: 4\n        },\n        ...\n    }\n}\n</code></pre>\n<p>For more details, see <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">Rich Text</a> please.</p>\n","properties":{"<style_name>":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"align":{"type":["string"],"description":"\n\n<p>Horizontal alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;left&#39;</code></li>\n<li><code class=\"codespan\">&#39;center&#39;</code></li>\n<li><code class=\"codespan\">&#39;right&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">align</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">align</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    align: right,\n    rich: {\n        a: {\n            // `align` is not set, then it will be right\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"left,center,right"}},"verticalAlign":{"type":["string"],"description":"\n\n<p>Vertical alignment of text, automatic by default.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;top&#39;</code></li>\n<li><code class=\"codespan\">&#39;middle&#39;</code></li>\n<li><code class=\"codespan\">&#39;bottom&#39;</code></li>\n</ul>\n<p>If <code class=\"codespan\">verticalAlign</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">verticalAlign</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    verticalAlign: bottom,\n    rich: {\n        a: {\n            // `verticalAlign` is not set, then it will be bottom\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"enum","options":"top,middle,bottom"}},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"backgroundColor":{"type":["string","Object"],"description":"\n\n<p>Background color of the text fragment.</p>\n<p>Can be color string, like <code class=\"codespan\">&#39;#123234&#39;</code>, <code class=\"codespan\">&#39;red&#39;</code>, <code class=\"codespan\">&#39;rgba(0,23,11,0.3)&#39;</code>.</p>\n<p>Or image can be used, for example:</p>\n<pre><code class=\"lang-js\">backgroundColor: {\n    image: &#39;xxx/xxx.png&#39;\n    // It can be URL of a image,\n    // or dataURI,\n    // or HTMLImageElement,\n    // or HTMLCanvasElement.\n}\n</code></pre>\n<p><code class=\"codespan\">width</code> or <code class=\"codespan\">height</code> can be specified when using background image, or\nauto adapted by default.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"},"default":"'transparent'"},"borderColor":{"type":["Color"],"description":"\n\n<p>Border color of the text fragment.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color","default":"#fff"}},"borderWidth":{"type":["number"],"description":"\n\n<p>Border width of the text fragment.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"borderRadius":{"type":["number"],"description":"\n\n<p>Border radius of the text fragment.</p>\n","uiControl":{"type":"vector","min":"0","dims":"LT,RT, RB, LB"},"default":0},"padding":{"type":["number","Array"],"description":"\n\n<p>Padding of the text fragment, for example:</p>\n<ul>\n<li><code class=\"codespan\">padding: [3, 4, 5, 6]</code>: represents padding of <code class=\"codespan\">[top, right, bottom, left]</code>.</li>\n<li><code class=\"codespan\">padding: 4</code>: represents <code class=\"codespan\">padding: [4, 4, 4, 4]</code>.</li>\n<li><code class=\"codespan\">padding: [3, 4]</code>: represents <code class=\"codespan\">padding: [3, 4, 3, 4]</code>.</li>\n</ul>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":0},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text block.</p>\n","uiControl":{"type":"color"},"default":"'transparent'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Show blur of the text block.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text block.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"width":{"type":["number","string"],"description":"<p>Width of the text block. It is the width of the text by default. In most cases, there is no need to specify it. You may want to use it in some cases like make simple table or using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p><code class=\"codespan\">width</code> can also be percent string, like <code class=\"codespan\">&#39;100%&#39;</code>, which represents the percent of <code class=\"codespan\">contentWidth</code> (that is, the width without <code class=\"codespan\">padding</code>) of its container box. It is based on <code class=\"codespan\">contentWidth</code> because that each text fragment is layout based on the <code class=\"codespan\">content box</code>, where it makes no sense that calculating width based on <code class=\"codespan\">outerWith</code> in prectice.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"height":{"type":["number","string"],"description":"<p>Height of the text block. It is the width of the text by default. You may want to use it in some cases like using background image (see <code class=\"codespan\">backgroundColor</code>).</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> specifies the width and height of the content, without <code class=\"codespan\">padding</code>.</p>\n<p>Notice, <code class=\"codespan\">width</code> and <code class=\"codespan\">height</code> only work when <code class=\"codespan\">rich</code> specified.</p>\n"},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n<p>If set as <code class=\"codespan\">&#39;inherit&#39;</code>, the color will assigned as visual color, such as series color.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0}}}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"data":{"type":["Array"],"description":"<pre><code class=\"lang-js\">data: [\n    [&quot;2015/11/09&quot;,10,&quot;DQ&quot;],\n    [&quot;2015/11/10&quot;,10,&quot;DQ&quot;],\n    [&quot;2015/11/11&quot;,10,&quot;DQ&quot;],\n    [&quot;2015/11/08&quot;,10,&quot;SS&quot;],\n    [&quot;2015/11/09&quot;,10,&quot;SS&quot;],\n    [&quot;2015/11/10&quot;,10,&quot;SS&quot;],\n    [&quot;2015/11/11&quot;,10,&quot;SS&quot;],\n    [&quot;2015/11/12&quot;,10,&quot;SS&quot;],\n    [&quot;2015/11/13&quot;,10,&quot;QG&quot;],\n    [&quot;2015/11/08&quot;,10,&quot;QG&quot;],\n    [&quot;2015/11/11&quot;,10,&quot;QG&quot;],\n    [&quot;2015/11/13&quot;,10,&quot;QG&quot;],\n]\n</code></pre>\n<p><strong>data specification: </strong></p>\n<p>As what is shown above, the data format of theme river is double dimensional array. Each item of the inner array consists of the time attribute , the value at a time point and the name of an event or theme. It needs to be noticed that you should provide an event or theme with a complete time quantum as main river. Other events and themes are based on the main river. The default value of time point should be set as 0. That is to say other events or themes are included in the main river. Once they are beyond the main river, the layout would be wrong. That is because a baseline should be calculated to draw each event as ribbon shape when the whole diagram layout is calculated. As the example above, the event &quot;SS&quot; is a main river. After dispose, we would complete these 3 default time points with the format of [&quot;2015/11/08&quot;,0,&quot;DQ&quot;], [&quot;2015/11/12&quot;,0,&quot;DQ&quot;], ［&quot;2015/11/13&quot;,0,&quot;DQ&quot;］, making it align with the main river. From what is mentioned, we could set default value on any position of a complete time period.</p>\n","items":{"type":"Object","properties":{"date":{"type":["string"],"description":"<p>the time attribute of time and theme.</p>\n"},"value":{"type":["number"],"description":"<p>the value of an event or theme at a time point.</p>\n"},"name":{"type":["string"],"description":"<p>the name of an event or theme.</p>\n"}}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}},{"type":["Object"],"description":"<p><strong>custom series</strong></p>\n<p><code class=\"codespan\">custom series</code> supports customizing graphic elements, and then generate more types of charts.</p>\n<p>echarts manages the creation, deletion, animation and interaction with other components (like <a href=\"#dataZoom\">dataZoom</a>、<a href=\"#visualMap\">visualMap</a>), which frees developers from handling those issue themselves.</p>\n<p><strong>For example, a &quot;x-range&quot; chart is made by custom sereis:</strong></p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=custom-profile&reset=1&edit=1\" width=\"800\" height=\"400\"></iframe>\n\n\n<p><strong><a href=\"https://echarts.apache.org/examples/en/index.html#chart-type-custom\" target=\"_blank\">More samples of custom series</a></strong></p>\n<p><strong><a href=\"tutorial.html#Custom%20Series\" target=\"_blank\">A tutotial of custom series</a></strong></p>\n<p><br>\n<strong>Customize the render logic (in renderItem method)</strong></p>\n<p><code class=\"codespan\">custom series</code> requires developers to write a render logic by themselves. This render logic is called <a href=\"#series-custom.renderItem\">renderItem</a>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">var option = {\n    ...,\n    series: [{\n        type: &#39;custom&#39;,\n        renderItem: function (params, api) {\n            var categoryIndex = api.value(0);\n            var start = api.coord([api.value(1), categoryIndex]);\n            var end = api.coord([api.value(2), categoryIndex]);\n            var height = api.size([0, 1])[1] * 0.6;\n\n            var rectShape = echarts.graphic.clipRectByRect({\n                x: start[0],\n                y: start[1] - height / 2,\n                width: end[0] - start[0],\n                height: height\n            }, {\n                x: params.coordSys.x,\n                y: params.coordSys.y,\n                width: params.coordSys.width,\n                height: params.coordSys.height\n            });\n\n            return rectShape &amp;&amp; {\n                type: &#39;rect&#39;,\n                shape: rectShape,\n                style: api.style()\n            };\n        },\n        data: data\n    }]\n}\n</code></pre>\n<p><a href=\"#series-custom.renderItem\">renderItem</a> will be called on each data item.</p>\n<p><a href=\"#series-custom.renderItem\">renderItem</a> provides two parameters:</p>\n<ul>\n<li><a href=\"#series-custom.renderItem.arguments.params\">params</a>: provides info about the current series and data and coordinate system.</li>\n<li><a href=\"#series-custom.renderItem.arguments.api\">api</a>: includes some methods.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem\">renderItem</a> method should returns graphic elements definitions.See <a href=\"#series-custom.renderItem.return\">renderItem.return</a>.</p>\n<p>Generally, the main process of <a href=\"#series-custom.renderItem\">renderItem</a> is that retrieve value from data and convert them to graphic elements on the current coordinate system. Two methods in <a href=\"#series-custom.renderItem.arguments.api\">renderItem.arguments.api</a> are always used in this procedure:</p>\n<ul>\n<li><a href=\"#series-custom.renderItem.arguments.api.value\">api.value(...)</a> is used to retrieve value from data. For example, <code class=\"codespan\">api.value(0)</code> retrieve the value of the first dimension in the current data item.</li>\n<li><a href=\"#series-custom.renderItem.arguments.api.coord\">api.coord(...)</a> is used to convert data to coordinate. For example, <code class=\"codespan\">var point = api.coord([api.value(0), api.value(1)])</code> converet the data to the point on the current coordinate system.</li>\n</ul>\n<p>Sometimes <a href=\"#series-custom.renderItem.arguments.api.size\">api.size(...)</a> method is needed, which calculates the size on the coordinate system by a given data range.</p>\n<p>Moreover, <a href=\"#series-custom.renderItem.arguments.api.style\">api.style(...)</a> method can be used to set style. It provides not only the style settings specified in <a href=\"#series-custom.itemStyle\">series.itemStyle</a>, but also the result of visual mapping. This method can also be called like <code class=\"codespan\">api.style({fill: &#39;green&#39;, stroke: &#39;yellow&#39;})</code> to override those style settings.</p>\n<p><br>\n<strong>Dimension mapping (by encode and dimension option)</strong></p>\n<p>In most cases, <a href=\"#series-custom.encode\">series.encode</a> needs to be specified when using <code class=\"codespan\">custom series</code> series, which indicate the mapping of dimensions, and then echarts can render appropriate axis by the extent of those data.</p>\n<p><code class=\"codespan\">encode.tooltip</code> and <code class=\"codespan\">encode.label</code> can also be specified to define the content of default <code class=\"codespan\">tooltip</code> and <code class=\"codespan\">label</code>.\n<a href=\"#series-custom.dimensions\">series.dimensions</a> can also be specified to defined names of each dimensions, which will be displayed in tooltip.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;custom&#39;,\n    renderItem: function () {\n        ...\n    },\n    encode: {\n        x: [2, 4, 3],\n        y: 1,\n        label: 0,\n        tooltip: [2, 4, 3]\n    }\n}\n</code></pre>\n<p><br>\n<strong>Controlled by dataZoom</strong></p>\n<p>When use <code class=\"codespan\">custom series</code> with <a href=\"#dataZoom\">dataZoom</a>, <a href=\"#dataZoom.filterMode\">dataZoom.filterMode</a> usually be set as <code class=\"codespan\">&#39;weakFilter&#39;</code>, which prevent <code class=\"codespan\">dataItem</code> from being filtered when only part of its dimensions are out of the current data window.</p>\n<p><br>\n<br>\n<strong>Difference between <code class=\"codespan\">dataIndex</code> and <code class=\"codespan\">dataIndexInside</code></strong></p>\n<ul>\n<li><code class=\"codespan\">dataIndex</code> is the index of a <code class=\"codespan\">dataItem</code> in the original data.</li>\n<li><code class=\"codespan\">dataIndexInside</code> is the index of a <code class=\"codespan\">dataItem</code> in the current data window (see <a href=\"#dataZoom\">dataZoom</a>.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.arguments.api\">renderItem.arguments.api</a> uses <code class=\"codespan\">dataIndexInside</code> as the input parameter but not <code class=\"codespan\">dataIndex</code>, because conversion from <code class=\"codespan\">dataIndex</code> to <code class=\"codespan\">dataIndexInside</code> is time-consuming.</p>\n<p><br>\n<strong>Event listener</strong></p>\n<pre><code class=\"lang-js\">chart.setOption({\n    // ...\n    series: {\n        type: &#39;custom&#39;,\n        renderItem: function () {\n            // ...\n            return {\n                type: &#39;group&#39;,\n                children: [{\n                    type: &#39;circle&#39;\n                    // ...\n                }, {\n                    type: &#39;circle&#39;,\n                    name: &#39;aaa&#39;,\n                    // User specified info, available\n                    // in event handler.\n                    info: 12345,\n                    // ...\n                }]\n            };\n        }\n    }\n});\nchart.on(&#39;click&#39;, {element: &#39;aaa&#39;}, function (params) {\n    // When the element with name &#39;aaa&#39; clicked,\n    // this method called.\n    console.log(params.info);\n});\n</code></pre>\n","properties":{"type":{"type":["string"],"description":"","default":"'custom'"},"id":{"type":["string"],"description":"<p>Component ID, not specified by default. If specified, it can be used to refer the component in option or API.</p>\n"},"name":{"type":["string"],"description":"<p>Series name used for displaying in <a href=\"#tooltip\">tooltip</a> and filtering with <a href=\"#legend\">legend</a>, or updating data and configuration with <code class=\"codespan\">setOption</code>.</p>\n"},"legendHoverLink":{"type":["boolean"],"description":"\n\n<p>Whether to enable highlighting chart when <a href=\"#legend\">legend</a> is being hovered.</p>\n","uiControl":{"type":"boolean","default":"true"},"default":true},"coordinateSystem":{"type":["string"],"description":"<p>The coordinate used in the series, whose options are:</p>\n<ul>\n<li><p><code class=\"codespan\">null</code> or <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>  No coordinate.</p>\n</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;cartesian2d&#39;</code></p>\n<p>  Use a two-dimensional rectangular coordinate (also known as Cartesian coordinate), with <a href=\"#series-custom.xAxisIndex\">xAxisIndex</a> and <a href=\"#series-custom.yAxisIndex\">yAxisIndex</a> to assign the corresponding axis component.</p>\n</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;polar&#39;</code></p>\n<p>  Use polar coordinates, with <a href=\"#series-custom.polarIndex\">polarIndex</a> to assign the corresponding polar coordinate component.</p>\n</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;geo&#39;</code></p>\n<p>  Use geographic coordinate, with <a href=\"#series-custom.geoIndex\">geoIndex</a> to assign the corresponding geographic coordinate components.</p>\n</li>\n</ul>\n<ul>\n<li><p><code class=\"codespan\">&#39;none&#39;</code></p>\n<p>  Do not use coordinate system.</p>\n</li>\n</ul>\n","default":"'cartesian2d'"},"xAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#xAxis\">x axis</a> to combine with, which is  useful for multiple x axes in one chart.</p>\n","default":0},"yAxisIndex":{"type":["number"],"description":"<p>Index of <a href=\"#yAxis\">y axis</a> to combine with, which is  useful for multiple y axes in one chart.</p>\n","default":0},"polarIndex":{"type":["number"],"description":"<p>Index of <a href=\"#polar\">polar coordinate</a> to combine with, which is useful for multiple polar axes in one chart.</p>\n","default":0},"geoIndex":{"type":["number"],"description":"<p>Index of <a href=\"#geo\">geographic coordinate</a> to combine with, which is useful for multiple geographic axes in one chart.</p>\n","default":0},"calendarIndex":{"type":["number"],"description":"<p>Index of <a href=\"#calendar\">calendar coordinates</a> to combine with, which is useful for multiple calendar coordinates in one chart.</p>\n","default":0},"renderItem":{"type":["Function"],"description":"<p><code class=\"codespan\">custom series</code> requires developers to write a render logic by themselves. This render logic is called <a href=\"#series-custom.renderItem\">renderItem</a>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">var option = {\n    ...,\n    series: [{\n        type: &#39;custom&#39;,\n        renderItem: function (params, api) {\n            var categoryIndex = api.value(0);\n            var start = api.coord([api.value(1), categoryIndex]);\n            var end = api.coord([api.value(2), categoryIndex]);\n            var height = api.size([0, 1])[1] * 0.6;\n\n            var rectShape = echarts.graphic.clipRectByRect({\n                x: start[0],\n                y: start[1] - height / 2,\n                width: end[0] - start[0],\n                height: height\n            }, {\n                x: params.coordSys.x,\n                y: params.coordSys.y,\n                width: params.coordSys.width,\n                height: params.coordSys.height\n            });\n\n            return rectShape &amp;&amp; {\n                type: &#39;rect&#39;,\n                shape: rectShape,\n                style: api.style()\n            };\n        },\n        data: data\n    }]\n}\n</code></pre>\n<p><a href=\"#series-custom.renderItem\">renderItem</a> will be called on each data item.</p>\n<p><a href=\"#series-custom.renderItem\">renderItem</a> provides two parameters:</p>\n<ul>\n<li><a href=\"#series-custom.renderItem.arguments.params\">params</a>: provides info about the current series and data and coordinate system.</li>\n<li><a href=\"#series-custom.renderItem.arguments.api\">api</a>: includes some methods.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem\">renderItem</a> method should returns graphic elements definitions.See <a href=\"#series-custom.renderItem.return\">renderItem.return</a>.</p>\n<p>Generally, the main process of <a href=\"#series-custom.renderItem\">renderItem</a> is that retrieve value from data and convert them to graphic elements on the current coordinate system. Two methods in <a href=\"#series-custom.renderItem.arguments.api\">renderItem.arguments.api</a> are always used in this procedure:</p>\n<ul>\n<li><a href=\"#series-custom.renderItem.arguments.api.value\">api.value(...)</a> is used to retrieve value from data. For example, <code class=\"codespan\">api.value(0)</code> retrieve the value of the first dimension in the current data item.</li>\n<li><a href=\"#series-custom.renderItem.arguments.api.coord\">api.coord(...)</a> is used to convert data to coordinate. For example, <code class=\"codespan\">var point = api.coord([api.value(0), api.value(1)])</code> converet the data to the point on the current coordinate system.</li>\n</ul>\n<p>Sometimes <a href=\"#series-custom.renderItem.arguments.api.size\">api.size(...)</a> method is needed, which calculates the size on the coordinate system by a given data range.</p>\n<p>Moreover, <a href=\"#series-custom.renderItem.arguments.api.style\">api.style(...)</a> method can be used to set style. It provides not only the style settings specified in <a href=\"#series-custom.itemStyle\">series.itemStyle</a>, but also the result of visual mapping. This method can also be called like <code class=\"codespan\">api.style({fill: &#39;green&#39;, stroke: &#39;yellow&#39;})</code> to override those style settings.</p>\n","properties":{"arguments":{"type":["*"],"description":"<p>Parameters of <code class=\"codespan\">renderItem</code>.</p>\n","properties":{"params":{"type":["Object"],"description":"<p>The first parameter of <code class=\"codespan\">renderItem</code>, including:</p>\n<pre><code class=\"lang-js\">{\n    context: // {string} An object that developers can store something temporarily here. Life cycle: current round of rendering.\n    seriesId: // {string} The id of this series.\n    seriesName: // {string} The name of this series.\n    seriesIndex: // {number} The index of this series.\n    dataIndex: // {number} The index of this data item.\n    dataIndexInside: // {number} The index of this data item in the current data window (see dataZoom).\n    dataInsideLength: // {number} The count of data in the current data window (see dataZoom).\n    actionType: // {string} The type of action that trigger this render.\n    coordSys: // coordSys is variable by different types of coordinate systems:\n    coordSys: {\n        type: &#39;cartesian2d&#39;,\n        x: // {number} x of grid rect\n        y: // {number} y of grid rect\n        width: // {number} width of grid rect\n        height: // {number} height of grid rect\n    },\n    coordSys: {\n        type: &#39;calendar&#39;,\n        x: // {number} x of calendar rect\n        y: // {number} y of calendar rect\n        width: // {number} width of calendar rect\n        height: // {number} height of calendar rect\n        cellWidth: // {number} calendar cellWidth\n        cellHeight: // {number} calendar cellHeight\n        rangeInfo: {\n            start: // date start of calendar.\n            end: // date end of calendar.\n            weeks: // number of weeks in calendar.\n            dayCount: // day count in calendar.\n        }\n    },\n    coordSys: {\n        type: &#39;geo&#39;,\n        x: // {number} x of geo rect\n        y: // {number} y of geo rect\n        width: // {number} width of geo rect\n        height: // {number} height of geo rect\n        zoom: // {number} zoom ratio, 1 if no zoom, 0.5 means shrink to 50%.\n    },\n    coordSys: {\n        type: &#39;polar&#39;,\n        cx: // {number} x of polar center.\n        cy: // {number} y of polar center.\n        r: // {number} outer radius of polar.\n        r0: // {number} inner radius of polar.\n    },\n    coordSys: {\n        type: &#39;singleAxis&#39;,\n        x: // {number} x of singleAxis rect\n        y: // {number} y of singleAxis rect\n        width: // {number} width of singleAxis rect\n        height: // {number} height of singleAxis rect\n    }\n}\n</code></pre>\n<p>Difference between <code class=\"codespan\">dataIndex</code> and <code class=\"codespan\">dataIndexInside</code>:</p>\n<ul>\n<li><code class=\"codespan\">dataIndex</code> is the index of a <code class=\"codespan\">dataItem</code> in the original data.</li>\n<li><code class=\"codespan\">dataIndexInside</code> is the index of a <code class=\"codespan\">dataItem</code> in the current data window (see <a href=\"#dataZoom\">dataZoom</a>.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.arguments.api\">renderItem.arguments.api</a> uses <code class=\"codespan\">dataIndexInside</code> as the input parameter but not <code class=\"codespan\">dataIndex</code>, because conversion from <code class=\"codespan\">dataIndex</code> to <code class=\"codespan\">dataIndexInside</code> is time-consuming.</p>\n"},"api":{"type":["Object"],"description":"<p>The second parameter of <code class=\"codespan\">renderItem</code>.</p>\n","properties":{"value":{"type":["Function"],"description":"<p>Get value on the given dimension.</p>\n<pre><code>@param {number} dimension The given dimension. (index from 0).\n@param {number} [dataIndexInside] In most cases it is not necessary.\n@return {number} The value.\n</code></pre>"},"coord":{"type":["Function"],"description":"<p>Convert data to coordinate.</p>\n<pre><code>@param {Array.&lt;number&gt;} data.\n@return {Array.&lt;number&gt;} Point on canvas, at least includes [x, y].\n        In polar, it also contains:\n        polar: [x, y, radius, angle]\n</code></pre>"},"size":{"type":["Function"],"description":"<p>Get the size by the given data range.</p>\n<p>For example, in <code class=\"codespan\">cartesian2d</code>, suppose calling <code class=\"codespan\">api.size([2, 4])</code> returns <code class=\"codespan\">[12.4, 55]</code>. It represents that on x axis, data range <code class=\"codespan\">2</code> corresponds to size <code class=\"codespan\">12.4</code>, and on y axis data range <code class=\"codespan\">4</code> corresponds to size <code class=\"codespan\">55</code>.</p>\n<p>In some coordinate systems (for example, polar) or when log axis is used, the size is different in different point. So the second parameter is necessary to calculate size on the given point.</p>\n<pre><code>@param {Array.&lt;number&gt;} dataSize Data range.\n@param {Array.&lt;number&gt;} dataItem The point where the size will be calculated.\n@return {Array.&lt;number&gt;} The size.\n</code></pre>"},"style":{"type":["Function"],"description":"<p>The method obtains style info defined in <a href=\"#series-custom.itemStyle\">series.itemStyle</a>, and visual info obtained by visual mapping, and return them. Those returned info can be assigned to <code class=\"codespan\">style</code> attribute of graphic element definition directly. Developers can also override style info by calling this method like this: <code class=\"codespan\">api.style({fill: &#39;green&#39;, stroke: &#39;yellow&#39;})</code>.</p>\n<pre><code>@param {Object} [extra] Extra style info.\n@param {number} [dataIndexInside] In most cases, this parameter is not necessary.\n@return {Object} Style info, which can be assigned to `style` attribute of graphic element definition directly.\n</code></pre>"},"styleEmphasis":{"type":["Function"],"description":"<p>The method obtains style info defined in <a href=\"#series-custom.itemStyle.emphasis\">series.itemStyle.emphasis</a>, and visual info obtained by visual mapping, and return them. Those returned info can be assigned to <code class=\"codespan\">style</code> attribute of graphic element definition directly. Developers can also override style info by calling this method like this: <code class=\"codespan\">api.style({fill: &#39;green&#39;, stroke: &#39;yellow&#39;})</code>.</p>\n<pre><code>@param {Object} [extra] Extra style info.\n@param {number} [dataIndexInside] In most cases, this parameter is not necessary.\n@return {Object} Style info, which can be assigned to `style` attribute of graphic element definition directly.\n</code></pre>"},"visual":{"type":["Function"],"description":"<p>Get the visual info. It is rarely be used.</p>\n<pre><code>@param {string} visualType &#39;color&#39;, &#39;symbol&#39;, &#39;symbolSize&#39;, ...\n@param {number} [dataIndexInside] In most cases, this parameter is not necessary.\n@return {string|number} The value of visual.\n</code></pre>"},"barLayout":{"type":["Function"],"description":"<p>When <code class=\"codespan\">barLayout</code> is needed, (for example, when attaching some extra graphic elements to bar chart), this method can be used to obtain bar layout info.</p>\n<p>See a <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-bar-trend\" target=\"_blank\">sample</a>.</p>\n<pre><code>@param {Object} opt\n@param {number} opt.count How many bars in each group.\n@param {number|string} [opt.barWidth] Width of a bar.\n        Can be an absolute value like `40` or a percent value like `&#39;60%&#39;`.\n        The percent is based on the calculated category width.\n@param {number|string} [opt.barMaxWidth] Max width of a bar.\n        Can be an absolute value like `40` or a percent value like `&#39;60%&#39;`.\n        The percent is based on the calculated category width.\n        Has higer priority than `opt.barWidth`.\n@param {number|string} [opt.barMinWidth] Min width of a bar.\n        Can be an absolute value like `40` or a percent value like `&#39;60%&#39;`.\n        The percent is based on the calculated category width.\n        Has higer priority than `opt.barWidth`.\n@param {number} [opt.barGap] Gap of bars in a group.\n@param {number} [opt.barCategoryGap] Gap of groups.\n@return {Array.&lt;Object&gt;} [{\n        width: {number} Width of a bar.\n        offset: {number} Offset of a bar, based on the left most edge.\n        offsetCenter: {number} bar Offset of a bar, based on the center of the bar.\n    }, ...]\n</code></pre>"},"currentSeriesIndices":{"type":["Function"],"description":"<p>Obtain the current series index. Notice that the <code class=\"codespan\">currentSeriesIndex</code> is different from <code class=\"codespan\">seriesIndex</code> when legend is used to filter some series.</p>\n<pre><code>@return {number}\n</code></pre>"},"font":{"type":["Function"],"description":"<p>Obtain font string, which can be used on style setting directly.</p>\n<pre><code>@param {Object} opt\n@param {string} [opt.fontStyle]\n@param {number} [opt.fontWeight]\n@param {number} [opt.fontSize]\n@param {string} [opt.fontFamily]\n@return {string} font string.\n</code></pre>"},"getWidth":{"type":["Function"],"description":"<pre><code>@return {number} Width of echarts containter.\n</code></pre>"},"getHeight":{"type":["Function"],"description":"<pre><code>@return {number} Height of echarts container.\n</code></pre>"},"getZr":{"type":["Function"],"description":"<pre><code>@return {module:zrender} zrender instance.\n</code></pre>"},"getDevicePixelRatio":{"type":["Function"],"description":"<pre><code>@return {number} The current devicePixelRatio.\n</code></pre>"}}}}},"return":{"type":["Object"],"description":"<p><code class=\"codespan\">renderItem</code> should returns graphic element definitions. Each graphic element is an object. See <a href=\"#graphic.elements\">graphic</a> for detailed info. (But width\\height\\top\\bottom is not supported here)</p>\n<p>If nothing should be rendered in this data item, just returns nothing.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">// Returns a rectangular.\n{\n    type: &#39;rect&#39;,\n    shape: {\n        x: x, y: y, width: width, height: height\n    },\n    style: api.style()\n}\n</code></pre>\n<pre><code class=\"lang-js\">// Returns a group of elements.\n{\n    type: &#39;group&#39;,\n    // If diffChildrenByName is set as `true`, `child.name` will be used\n    // to diff children, which improves animation transition but degrade\n    // performance. The default value is `false`.\n    // diffChildrenByName: true,\n    children: [{\n        type: &#39;circle&#39;,\n        shape: {\n            cx: cx, cy: cy, r: r\n        },\n        style: api.style()\n    }, {\n        type: &#39;line&#39;,\n        shape: {\n            x1: x1, y1: y1, x2: x2, y2: y2\n        },\n        style: api.style()\n    }]\n}\n</code></pre>\n"},"return_group":{"type":["Object"],"description":"<p><code class=\"codespan\">group</code> is the only type that can contain children, so that a group of elements can be positioned and transformed together.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#series-custom.renderItem.return_image\">image</a>,\n<a href=\"#series-custom.renderItem.return_text\">text</a>,\n<a href=\"#series-custom.renderItem.return_circle\">circle</a>,\n<a href=\"#series-custom.renderItem.return_sector\">sector</a>,\n<a href=\"#series-custom.renderItem.return_ring\">ring</a>,\n<a href=\"#series-custom.renderItem.return_polygon\">polygon</a>,\n<a href=\"#series-custom.renderItem.return_polyline\">polyline</a>,\n<a href=\"#series-custom.renderItem.return_rect\">rect</a>,\n<a href=\"#series-custom.renderItem.return_line\">line</a>,\n<a href=\"#series-custom.renderItem.return_bezierCurve\">bezierCurve</a>,\n<a href=\"#series-custom.renderItem.return_arc\">arc</a>,\n<a href=\"#series-custom.renderItem.return_group\">group</a>,</p>\n","default":"group"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_group.x\">x</a> and <a href=\"#series-custom.renderItem.return_group.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_group.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_group.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_group.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_group.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_group.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_group.x\">x</a> and <a href=\"#series-custom.renderItem.return_group.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_group.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_group.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_group.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_group.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_group.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_group.x\">x</a> and <a href=\"#series-custom.renderItem.return_group.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_group.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_group.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_group.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_group.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_group.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_group.x\">x</a> and <a href=\"#series-custom.renderItem.return_group.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_group.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_group.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_group.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_group.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_group.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_group.x\">x</a> and <a href=\"#series-custom.renderItem.return_group.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_group.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_group.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_group.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_group.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_group.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_group.x\">x</a> and <a href=\"#series-custom.renderItem.return_group.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_group.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_group.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_group.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_group.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_group.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_group.x\">x</a> and <a href=\"#series-custom.renderItem.return_group.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_group.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_group.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_group.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_group.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_group.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.</p>\n<p>The properties can only be:</p>\n<ul>\n<li>Transform related properties: <a href=\"#series-custom.renderItem.return_group.x\"><code class=\"codespan\">&#39;x&#39;</code></a>, <a href=\"#series-custom.renderItem.return_group.y\"><code class=\"codespan\">&#39;y&#39;</code></a>, <a href=\"#series-custom.renderItem.return_group.scaleX\"><code class=\"codespan\">&#39;scaleX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_group.scaleY\"><code class=\"codespan\">&#39;scaleY&#39;</code></a>, <a href=\"#series-custom.renderItem.return_group.rotation\"><code class=\"codespan\">&#39;rotation&#39;</code></a>, <a href=\"#series-custom.renderItem.return_group.originX\"><code class=\"codespan\">&#39;originX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_group.originY\"><code class=\"codespan\">&#39;originY&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      var coord = api.coord([api.value(0), api.value[1]);\n      return {\n          type: &#39;rect&#39;,\n          x: coord[0],\n          y: coord[1],\n          shape: {\n              x: 0,\n              y: 0,\n              width: api.value(2),\n              height: 100\n          },\n          transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;]\n      }\n  }\n</code></pre>\n</li>\n<li>Shortcut to transition all of the properties in <a href=\"#series-custom.renderItem.return_group.shape\"><code class=\"codespan\">&#39;shape&#39;</code></a>, <a href=\"#series-custom.renderItem.return_group.style\">&#39;<code class=\"codespan\">style&#39;</code></a>, <a href=\"#series-custom.renderItem.return_group.extra\"><code class=\"codespan\">&#39;extra&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3)\n          },\n          // Indicate that all props in `shape` will\n          // have transition animation.\n          transition: &#39;shape&#39;,\n      };\n  }\n</code></pre>\n  It is equivalent to:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3),\n              // This usage can only enable part of the\n              // properties transition.\n              transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;, &#39;height&#39;]\n          }\n      };\n  }\n</code></pre>\n</li>\n</ul>\n<p>By default, <a href=\"#series-custom.renderItem.return_group.x\"><code class=\"codespan\">&#39;x&#39;</code></a> and <a href=\"#series-custom.renderItem.return_group.y\"><code class=\"codespan\">&#39;y&#39;</code></a> are transitioned. If you want to disable the default transition, just set it as:</p>\n<pre><code class=\"lang-js\">transition: [] // Am empty array.\n</code></pre>\n<p>See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/custom-transition-simple&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> please.</p>\n","default":"['x', 'y']"},"z2":{"type":["number"],"description":"<p>Define the overlap relationship between graphic elements.</p>\n","default":"undefined"},"name":{"type":["string"],"description":"<p>See <a href=\"#series-custom.renderItem.return_group.diffChildrenByName\">diffChildrenByName</a>.</p>\n","default":"undefined"},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"width":{"type":["number"],"description":"<p>Specify width of this <code class=\"codespan\">group</code>.</p>\n<p>This width is only used for the positioning of its children.</p>\n<p>When width is <code class=\"codespan\">0</code>, children can also be positioned according to its parent using <code class=\"codespan\">left: &#39;center&#39;</code>.</p>\n","default":0},"height":{"type":["number"],"description":"<p>Specify height of this <code class=\"codespan\">group</code>.</p>\n<p>This height is only used for the positioning of its children.</p>\n<p>When height is <code class=\"codespan\">0</code>, children can also be positioned according to its parent using <code class=\"codespan\">top: &#39;middle&#39;</code>.</p>\n","default":0},"diffChildrenByName":{"type":["boolean"],"description":"<p>In <a href=\"#series-custom\">custom series</a>, when <code class=\"codespan\">diffChildrenByName</code> is set as <code class=\"codespan\">true</code>, for each <a href=\"#series-custom.renderItem.return_group\">group</a> returned from <a href=\"#series-custom.renderItem\">renderItem</a>, &quot;diff&quot; will be performed to its <a href=\"#series-custom.renderItem.return_group.children\">children</a> according to the <a href=\"#series-custom.renderItem.return_polygon.name\">name</a> attribute of each graphic elements. Here &quot;diff&quot; means that map the coming graphic elements to the existing graphic elements when repainting according to <code class=\"codespan\">name</code>, which enables the transition animation if data is modified.</p>\n<p>But notice that the operation is performance consuming, do not use it for large data amount.</p>\n","default":false},"children":{"type":["Array"],"description":"<p>A list of children, each item is a declaration of an element.</p>\n"}}},"return_path":{"type":["Object"],"description":"<p>Use <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> to describe a path. Can be used to draw icons or any other shapes fitting the specified size by auto transforming.</p>\n<p>See examples:\n<a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-calendar-icon\" target=\"_blank\">icons</a> and <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-gantt-flight\" target=\"_blank\">shapes</a>.</p>\n<p>About width/height, cover/contain, see\n<a href=\"#series-custom.renderItem.return_path.shape.layout\">layout</a>.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#series-custom.renderItem.return_image\">image</a>,\n<a href=\"#series-custom.renderItem.return_text\">text</a>,\n<a href=\"#series-custom.renderItem.return_circle\">circle</a>,\n<a href=\"#series-custom.renderItem.return_sector\">sector</a>,\n<a href=\"#series-custom.renderItem.return_ring\">ring</a>,\n<a href=\"#series-custom.renderItem.return_polygon\">polygon</a>,\n<a href=\"#series-custom.renderItem.return_polyline\">polyline</a>,\n<a href=\"#series-custom.renderItem.return_rect\">rect</a>,\n<a href=\"#series-custom.renderItem.return_line\">line</a>,\n<a href=\"#series-custom.renderItem.return_bezierCurve\">bezierCurve</a>,\n<a href=\"#series-custom.renderItem.return_arc\">arc</a>,\n<a href=\"#series-custom.renderItem.return_group\">group</a>,</p>\n","default":"path"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_path.x\">x</a> and <a href=\"#series-custom.renderItem.return_path.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_path.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_path.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_path.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_path.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_path.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_path.x\">x</a> and <a href=\"#series-custom.renderItem.return_path.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_path.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_path.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_path.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_path.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_path.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_path.x\">x</a> and <a href=\"#series-custom.renderItem.return_path.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_path.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_path.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_path.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_path.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_path.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_path.x\">x</a> and <a href=\"#series-custom.renderItem.return_path.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_path.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_path.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_path.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_path.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_path.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_path.x\">x</a> and <a href=\"#series-custom.renderItem.return_path.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_path.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_path.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_path.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_path.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_path.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_path.x\">x</a> and <a href=\"#series-custom.renderItem.return_path.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_path.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_path.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_path.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_path.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_path.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_path.x\">x</a> and <a href=\"#series-custom.renderItem.return_path.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_path.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_path.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_path.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_path.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_path.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.</p>\n<p>The properties can only be:</p>\n<ul>\n<li>Transform related properties: <a href=\"#series-custom.renderItem.return_path.x\"><code class=\"codespan\">&#39;x&#39;</code></a>, <a href=\"#series-custom.renderItem.return_path.y\"><code class=\"codespan\">&#39;y&#39;</code></a>, <a href=\"#series-custom.renderItem.return_path.scaleX\"><code class=\"codespan\">&#39;scaleX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_path.scaleY\"><code class=\"codespan\">&#39;scaleY&#39;</code></a>, <a href=\"#series-custom.renderItem.return_path.rotation\"><code class=\"codespan\">&#39;rotation&#39;</code></a>, <a href=\"#series-custom.renderItem.return_path.originX\"><code class=\"codespan\">&#39;originX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_path.originY\"><code class=\"codespan\">&#39;originY&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      var coord = api.coord([api.value(0), api.value[1]);\n      return {\n          type: &#39;rect&#39;,\n          x: coord[0],\n          y: coord[1],\n          shape: {\n              x: 0,\n              y: 0,\n              width: api.value(2),\n              height: 100\n          },\n          transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;]\n      }\n  }\n</code></pre>\n</li>\n<li>Shortcut to transition all of the properties in <a href=\"#series-custom.renderItem.return_path.shape\"><code class=\"codespan\">&#39;shape&#39;</code></a>, <a href=\"#series-custom.renderItem.return_path.style\">&#39;<code class=\"codespan\">style&#39;</code></a>, <a href=\"#series-custom.renderItem.return_path.extra\"><code class=\"codespan\">&#39;extra&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3)\n          },\n          // Indicate that all props in `shape` will\n          // have transition animation.\n          transition: &#39;shape&#39;,\n      };\n  }\n</code></pre>\n  It is equivalent to:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3),\n              // This usage can only enable part of the\n              // properties transition.\n              transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;, &#39;height&#39;]\n          }\n      };\n  }\n</code></pre>\n</li>\n</ul>\n<p>By default, <a href=\"#series-custom.renderItem.return_path.x\"><code class=\"codespan\">&#39;x&#39;</code></a> and <a href=\"#series-custom.renderItem.return_path.y\"><code class=\"codespan\">&#39;y&#39;</code></a> are transitioned. If you want to disable the default transition, just set it as:</p>\n<pre><code class=\"lang-js\">transition: [] // Am empty array.\n</code></pre>\n<p>See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/custom-transition-simple&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> please.</p>\n","default":"['x', 'y']"},"morph":{"type":["boolean"],"description":"<p>Whether to enable morphing animation.</p>\n<p><strong>When morphing animation happen?</strong></p>\n<p>If <code class=\"codespan\">morph</code> is set as <code class=\"codespan\">true</code>, the morphing animation will happen according to the following rule:</p>\n<p>Each time the render process happen, custom series will diff the old data and the new data. If a set of old data items (say, &quot;old set&quot;) are value-equal to a set of new data items (say, &quot;new set&quot;) in name or the specified dimensions (see parameter <a href=\"api.html#echartsInstance.setOption\" target=\"_blank\">transition</a> in <code class=\"codespan\">setOption</code>), we found a pair of sets as transition candidates.</p>\n<p>Three type of transition animation can be performed between the two sets:</p>\n<ul>\n<li>one-to-one: if both the two sets has only one data item.</li>\n<li>one-to-many(separate): if the &quot;old set&quot; has only one data item, and the &quot;new set&quot; has more than one data items.</li>\n<li>many-to-one(combine): if the &quot;old set&quot; has more than one data items, and the &quot;new set&quot; has only one data item.</li>\n</ul>\n<p>Note: we do not support transition animation for the case many-to-many.</p>\n<p>Then custom series find graphic elements that has <code class=\"codespan\">morph: true</code> declared in these two sets, and map them for one to one morphing or combining or separating.</p>\n<p>See examples: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-one-to-one-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-one-to-one-morph</a> and\n<a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-combine-separate-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-combine-separate-morph</a>.</p>\n","default":false},"z2":{"type":["number"],"description":"<p>Define the overlap relationship between graphic elements.</p>\n","default":"undefined"},"name":{"type":["string"],"description":"<p>See <a href=\"#series-custom.renderItem.return_path.diffChildrenByName\">diffChildrenByName</a>.</p>\n","default":"undefined"},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"pathData":{"type":["string"],"description":"<p><a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a>.</p>\n<p>For example, <code class=\"codespan\">&#39;M0,0 L0,-20 L30,-20 C42,-20 38,-1 50,-1 L70,-1 L70,0 Z&#39;</code>.</p>\n<p>If <a href=\"#series-custom.renderItem.return_path.shape.width\">width</a>, <a href=\"#series-custom.renderItem.return_path.shape.height\">height</a>, <a href=\"#series-custom.renderItem.return_path.shape.x\">x</a> and <a href=\"#series-custom.renderItem.return_path.shape.y\">y</a> specified, <code class=\"codespan\">pathData</code> will be transformed to fit the defined rect. If they are not specified, do not do that.</p>\n<p><a href=\"#series-custom.renderItem.return_path.shape.layout\">layout</a> can be used to specify the transform strategy.</p>\n<p>See examples:\n<a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-calendar-icon\" target=\"_blank\">icons</a> and <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-gantt-flight\" target=\"_blank\">shapes</a>.</p>\n"},"d":{"type":["string"],"description":"<p>Alias of <a href=\"#series-custom.renderItem.return_path.shape.pathData\">pathData</a>.</p>\n"},"layout":{"type":["string"],"description":"<p>If <a href=\"#series-custom.renderItem.return_path.shape.width\">width</a>, <a href=\"#series-custom.renderItem.return_path.shape.height\">height</a>, <a href=\"#series-custom.renderItem.return_path.shape.x\">x</a> and <a href=\"#series-custom.renderItem.return_path.shape.y\">y</a> specified, <code class=\"codespan\">pathData</code> will be transformed to fit the defined rect.</p>\n<p><code class=\"codespan\">layout</code> can be used to specify the transform strategy.</p>\n<p>Optional value:</p>\n<ul>\n<li><code class=\"codespan\">&#39;center&#39;</code>: Keep aspect ratio, put the path in the center of the rect, expand as far as possible but never overflow.</li>\n<li><code class=\"codespan\">&#39;cover&#39;</code>: Transform the path according to the aspect ratio of the rect, fill the rect and do not overflow.</li>\n</ul>\n","default":"'center'"},"x":{"type":["number"],"description":"<p>The x value of the left-top corner of the element in the coordinate system of its parent.</p>\n","default":0},"y":{"type":["number"],"description":"<p>The y value of the left-top corner of the element in the coordinate system of its parent.</p>\n","default":0},"width":{"type":["number"],"description":"<p>The width of the shape of the element.</p>\n","default":0},"height":{"type":["numbr"],"description":"<p>The height of the shape of the element.</p>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">shape</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `shape` will\n        // have transition animation.\n        transition: &#39;shape&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">style</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `style` will\n        // have transition animation.\n        transition: &#39;style&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of the element.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When it&#39;s highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state, available when <code class=\"codespan\">focus</code> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state, available when <a href=\"#series-custom.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}}}},"return_image":{"type":["Object"],"description":"","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#series-custom.renderItem.return_image\">image</a>,\n<a href=\"#series-custom.renderItem.return_text\">text</a>,\n<a href=\"#series-custom.renderItem.return_circle\">circle</a>,\n<a href=\"#series-custom.renderItem.return_sector\">sector</a>,\n<a href=\"#series-custom.renderItem.return_ring\">ring</a>,\n<a href=\"#series-custom.renderItem.return_polygon\">polygon</a>,\n<a href=\"#series-custom.renderItem.return_polyline\">polyline</a>,\n<a href=\"#series-custom.renderItem.return_rect\">rect</a>,\n<a href=\"#series-custom.renderItem.return_line\">line</a>,\n<a href=\"#series-custom.renderItem.return_bezierCurve\">bezierCurve</a>,\n<a href=\"#series-custom.renderItem.return_arc\">arc</a>,\n<a href=\"#series-custom.renderItem.return_group\">group</a>,</p>\n","default":"image"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_image.x\">x</a> and <a href=\"#series-custom.renderItem.return_image.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_image.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_image.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_image.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_image.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_image.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_image.x\">x</a> and <a href=\"#series-custom.renderItem.return_image.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_image.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_image.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_image.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_image.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_image.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_image.x\">x</a> and <a href=\"#series-custom.renderItem.return_image.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_image.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_image.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_image.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_image.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_image.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_image.x\">x</a> and <a href=\"#series-custom.renderItem.return_image.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_image.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_image.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_image.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_image.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_image.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_image.x\">x</a> and <a href=\"#series-custom.renderItem.return_image.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_image.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_image.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_image.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_image.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_image.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_image.x\">x</a> and <a href=\"#series-custom.renderItem.return_image.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_image.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_image.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_image.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_image.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_image.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_image.x\">x</a> and <a href=\"#series-custom.renderItem.return_image.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_image.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_image.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_image.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_image.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_image.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.</p>\n<p>The properties can only be:</p>\n<ul>\n<li>Transform related properties: <a href=\"#series-custom.renderItem.return_image.x\"><code class=\"codespan\">&#39;x&#39;</code></a>, <a href=\"#series-custom.renderItem.return_image.y\"><code class=\"codespan\">&#39;y&#39;</code></a>, <a href=\"#series-custom.renderItem.return_image.scaleX\"><code class=\"codespan\">&#39;scaleX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_image.scaleY\"><code class=\"codespan\">&#39;scaleY&#39;</code></a>, <a href=\"#series-custom.renderItem.return_image.rotation\"><code class=\"codespan\">&#39;rotation&#39;</code></a>, <a href=\"#series-custom.renderItem.return_image.originX\"><code class=\"codespan\">&#39;originX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_image.originY\"><code class=\"codespan\">&#39;originY&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      var coord = api.coord([api.value(0), api.value[1]);\n      return {\n          type: &#39;rect&#39;,\n          x: coord[0],\n          y: coord[1],\n          shape: {\n              x: 0,\n              y: 0,\n              width: api.value(2),\n              height: 100\n          },\n          transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;]\n      }\n  }\n</code></pre>\n</li>\n<li>Shortcut to transition all of the properties in <a href=\"#series-custom.renderItem.return_image.shape\"><code class=\"codespan\">&#39;shape&#39;</code></a>, <a href=\"#series-custom.renderItem.return_image.style\">&#39;<code class=\"codespan\">style&#39;</code></a>, <a href=\"#series-custom.renderItem.return_image.extra\"><code class=\"codespan\">&#39;extra&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3)\n          },\n          // Indicate that all props in `shape` will\n          // have transition animation.\n          transition: &#39;shape&#39;,\n      };\n  }\n</code></pre>\n  It is equivalent to:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3),\n              // This usage can only enable part of the\n              // properties transition.\n              transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;, &#39;height&#39;]\n          }\n      };\n  }\n</code></pre>\n</li>\n</ul>\n<p>By default, <a href=\"#series-custom.renderItem.return_image.x\"><code class=\"codespan\">&#39;x&#39;</code></a> and <a href=\"#series-custom.renderItem.return_image.y\"><code class=\"codespan\">&#39;y&#39;</code></a> are transitioned. If you want to disable the default transition, just set it as:</p>\n<pre><code class=\"lang-js\">transition: [] // Am empty array.\n</code></pre>\n<p>See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/custom-transition-simple&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> please.</p>\n","default":"['x', 'y']"},"z2":{"type":["number"],"description":"<p>Define the overlap relationship between graphic elements.</p>\n","default":"undefined"},"name":{"type":["string"],"description":"<p>See <a href=\"#series-custom.renderItem.return_image.diffChildrenByName\">diffChildrenByName</a>.</p>\n","default":"undefined"},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"style":{"type":["Object"],"description":"","properties":{"image":{"type":["string"],"description":"<p>Specify content of the image, can be a URL, or <a href=\"https://tools.ietf.org/html/rfc2397\" target=\"_blank\">dataURI</a>.</p>\n"},"x":{"type":["number"],"description":"<p>The x value of the left-top corner of the element in the coordinate system of its parent.</p>\n","default":0},"y":{"type":["number"],"description":"<p>The y value of the left-top corner of the element in the coordinate system of its parent.</p>\n","default":0},"width":{"type":["number"],"description":"<p>The width of the shape of the element.</p>\n","default":0},"height":{"type":["numbr"],"description":"<p>The height of the shape of the element.</p>\n<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","default":0},"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">style</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `style` will\n        // have transition animation.\n        transition: &#39;style&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of the element.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When it&#39;s highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state, available when <code class=\"codespan\">focus</code> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state, available when <a href=\"#series-custom.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}}}},"return_text":{"type":["Object"],"description":"<p>Text block.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#series-custom.renderItem.return_image\">image</a>,\n<a href=\"#series-custom.renderItem.return_text\">text</a>,\n<a href=\"#series-custom.renderItem.return_circle\">circle</a>,\n<a href=\"#series-custom.renderItem.return_sector\">sector</a>,\n<a href=\"#series-custom.renderItem.return_ring\">ring</a>,\n<a href=\"#series-custom.renderItem.return_polygon\">polygon</a>,\n<a href=\"#series-custom.renderItem.return_polyline\">polyline</a>,\n<a href=\"#series-custom.renderItem.return_rect\">rect</a>,\n<a href=\"#series-custom.renderItem.return_line\">line</a>,\n<a href=\"#series-custom.renderItem.return_bezierCurve\">bezierCurve</a>,\n<a href=\"#series-custom.renderItem.return_arc\">arc</a>,\n<a href=\"#series-custom.renderItem.return_group\">group</a>,</p>\n","default":"text"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_text.x\">x</a> and <a href=\"#series-custom.renderItem.return_text.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_text.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_text.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_text.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_text.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_text.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_text.x\">x</a> and <a href=\"#series-custom.renderItem.return_text.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_text.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_text.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_text.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_text.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_text.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_text.x\">x</a> and <a href=\"#series-custom.renderItem.return_text.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_text.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_text.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_text.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_text.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_text.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_text.x\">x</a> and <a href=\"#series-custom.renderItem.return_text.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_text.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_text.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_text.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_text.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_text.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_text.x\">x</a> and <a href=\"#series-custom.renderItem.return_text.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_text.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_text.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_text.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_text.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_text.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_text.x\">x</a> and <a href=\"#series-custom.renderItem.return_text.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_text.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_text.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_text.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_text.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_text.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_text.x\">x</a> and <a href=\"#series-custom.renderItem.return_text.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_text.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_text.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_text.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_text.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_text.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.</p>\n<p>The properties can only be:</p>\n<ul>\n<li>Transform related properties: <a href=\"#series-custom.renderItem.return_text.x\"><code class=\"codespan\">&#39;x&#39;</code></a>, <a href=\"#series-custom.renderItem.return_text.y\"><code class=\"codespan\">&#39;y&#39;</code></a>, <a href=\"#series-custom.renderItem.return_text.scaleX\"><code class=\"codespan\">&#39;scaleX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_text.scaleY\"><code class=\"codespan\">&#39;scaleY&#39;</code></a>, <a href=\"#series-custom.renderItem.return_text.rotation\"><code class=\"codespan\">&#39;rotation&#39;</code></a>, <a href=\"#series-custom.renderItem.return_text.originX\"><code class=\"codespan\">&#39;originX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_text.originY\"><code class=\"codespan\">&#39;originY&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      var coord = api.coord([api.value(0), api.value[1]);\n      return {\n          type: &#39;rect&#39;,\n          x: coord[0],\n          y: coord[1],\n          shape: {\n              x: 0,\n              y: 0,\n              width: api.value(2),\n              height: 100\n          },\n          transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;]\n      }\n  }\n</code></pre>\n</li>\n<li>Shortcut to transition all of the properties in <a href=\"#series-custom.renderItem.return_text.shape\"><code class=\"codespan\">&#39;shape&#39;</code></a>, <a href=\"#series-custom.renderItem.return_text.style\">&#39;<code class=\"codespan\">style&#39;</code></a>, <a href=\"#series-custom.renderItem.return_text.extra\"><code class=\"codespan\">&#39;extra&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3)\n          },\n          // Indicate that all props in `shape` will\n          // have transition animation.\n          transition: &#39;shape&#39;,\n      };\n  }\n</code></pre>\n  It is equivalent to:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3),\n              // This usage can only enable part of the\n              // properties transition.\n              transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;, &#39;height&#39;]\n          }\n      };\n  }\n</code></pre>\n</li>\n</ul>\n<p>By default, <a href=\"#series-custom.renderItem.return_text.x\"><code class=\"codespan\">&#39;x&#39;</code></a> and <a href=\"#series-custom.renderItem.return_text.y\"><code class=\"codespan\">&#39;y&#39;</code></a> are transitioned. If you want to disable the default transition, just set it as:</p>\n<pre><code class=\"lang-js\">transition: [] // Am empty array.\n</code></pre>\n<p>See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/custom-transition-simple&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> please.</p>\n","default":"['x', 'y']"},"z2":{"type":["number"],"description":"<p>Define the overlap relationship between graphic elements.</p>\n","default":"undefined"},"name":{"type":["string"],"description":"<p>See <a href=\"#series-custom.renderItem.return_text.diffChildrenByName\">diffChildrenByName</a>.</p>\n","default":"undefined"},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"style":{"type":["Object"],"description":"","properties":{"text":{"type":["string"],"description":"<p>Text content. <code class=\"codespan\">\\n</code> can be used as a line break.</p>\n","default":"''"},"x":{"type":["number"],"description":"<p>The x value of the left-top corner of the element in the coordinate system of its parent.</p>\n","default":0},"y":{"type":["number"],"description":"<p>The y value of the left-top corner of the element in the coordinate system of its parent.</p>\n","default":0},"font":{"type":["string"],"description":"<p>Font size, font type, font weight, font color, follow the form of <a href=\"https://developer.mozilla.org/en-US/docs/Web/CSS/font\" target=\"_blank\">css font</a>.</p>\n<p>For example:</p>\n<pre><code>// size | family\nfont: &#39;2em &quot;STHeiti&quot;, sans-serif&#39;\n\n// style | weight | size | family\nfont: &#39;italic bolder 16px cursive&#39;\n\n// weight | size | family\nfont: &#39;bolder 2em &quot;Microsoft YaHei&quot;, sans-serif&#39;\n</code></pre>"},"textAlign":{"type":["string"],"description":"<p>Text horizontal alignment. Optional values: <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n<p><code class=\"codespan\">&#39;left&#39;</code> means the left side of the text block is specified by the <a href=\"#series-custom.renderItem.return_text.style.x\">style.x</a>, while <code class=\"codespan\">&#39;right&#39;</code> means the right side of the text block is specified by <a href=\"#series-custom.renderItem.return_text.style.y\">style.y</a>.</p>\n","default":"'left'"},"textVerticalAlign":{"type":["string"],"description":"<p>Text vertical alignment. Optional values: <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n"},"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">style</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `style` will\n        // have transition animation.\n        transition: &#39;style&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of the element.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When it&#39;s highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state, available when <code class=\"codespan\">focus</code> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state, available when <a href=\"#series-custom.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}}}},"return_rect":{"type":["Object"],"description":"<p>Rectangle element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#series-custom.renderItem.return_image\">image</a>,\n<a href=\"#series-custom.renderItem.return_text\">text</a>,\n<a href=\"#series-custom.renderItem.return_circle\">circle</a>,\n<a href=\"#series-custom.renderItem.return_sector\">sector</a>,\n<a href=\"#series-custom.renderItem.return_ring\">ring</a>,\n<a href=\"#series-custom.renderItem.return_polygon\">polygon</a>,\n<a href=\"#series-custom.renderItem.return_polyline\">polyline</a>,\n<a href=\"#series-custom.renderItem.return_rect\">rect</a>,\n<a href=\"#series-custom.renderItem.return_line\">line</a>,\n<a href=\"#series-custom.renderItem.return_bezierCurve\">bezierCurve</a>,\n<a href=\"#series-custom.renderItem.return_arc\">arc</a>,\n<a href=\"#series-custom.renderItem.return_group\">group</a>,</p>\n","default":"rect"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_rect.x\">x</a> and <a href=\"#series-custom.renderItem.return_rect.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_rect.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_rect.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_rect.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_rect.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_rect.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_rect.x\">x</a> and <a href=\"#series-custom.renderItem.return_rect.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_rect.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_rect.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_rect.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_rect.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_rect.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_rect.x\">x</a> and <a href=\"#series-custom.renderItem.return_rect.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_rect.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_rect.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_rect.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_rect.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_rect.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_rect.x\">x</a> and <a href=\"#series-custom.renderItem.return_rect.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_rect.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_rect.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_rect.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_rect.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_rect.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_rect.x\">x</a> and <a href=\"#series-custom.renderItem.return_rect.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_rect.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_rect.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_rect.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_rect.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_rect.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_rect.x\">x</a> and <a href=\"#series-custom.renderItem.return_rect.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_rect.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_rect.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_rect.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_rect.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_rect.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_rect.x\">x</a> and <a href=\"#series-custom.renderItem.return_rect.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_rect.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_rect.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_rect.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_rect.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_rect.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.</p>\n<p>The properties can only be:</p>\n<ul>\n<li>Transform related properties: <a href=\"#series-custom.renderItem.return_rect.x\"><code class=\"codespan\">&#39;x&#39;</code></a>, <a href=\"#series-custom.renderItem.return_rect.y\"><code class=\"codespan\">&#39;y&#39;</code></a>, <a href=\"#series-custom.renderItem.return_rect.scaleX\"><code class=\"codespan\">&#39;scaleX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_rect.scaleY\"><code class=\"codespan\">&#39;scaleY&#39;</code></a>, <a href=\"#series-custom.renderItem.return_rect.rotation\"><code class=\"codespan\">&#39;rotation&#39;</code></a>, <a href=\"#series-custom.renderItem.return_rect.originX\"><code class=\"codespan\">&#39;originX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_rect.originY\"><code class=\"codespan\">&#39;originY&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      var coord = api.coord([api.value(0), api.value[1]);\n      return {\n          type: &#39;rect&#39;,\n          x: coord[0],\n          y: coord[1],\n          shape: {\n              x: 0,\n              y: 0,\n              width: api.value(2),\n              height: 100\n          },\n          transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;]\n      }\n  }\n</code></pre>\n</li>\n<li>Shortcut to transition all of the properties in <a href=\"#series-custom.renderItem.return_rect.shape\"><code class=\"codespan\">&#39;shape&#39;</code></a>, <a href=\"#series-custom.renderItem.return_rect.style\">&#39;<code class=\"codespan\">style&#39;</code></a>, <a href=\"#series-custom.renderItem.return_rect.extra\"><code class=\"codespan\">&#39;extra&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3)\n          },\n          // Indicate that all props in `shape` will\n          // have transition animation.\n          transition: &#39;shape&#39;,\n      };\n  }\n</code></pre>\n  It is equivalent to:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3),\n              // This usage can only enable part of the\n              // properties transition.\n              transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;, &#39;height&#39;]\n          }\n      };\n  }\n</code></pre>\n</li>\n</ul>\n<p>By default, <a href=\"#series-custom.renderItem.return_rect.x\"><code class=\"codespan\">&#39;x&#39;</code></a> and <a href=\"#series-custom.renderItem.return_rect.y\"><code class=\"codespan\">&#39;y&#39;</code></a> are transitioned. If you want to disable the default transition, just set it as:</p>\n<pre><code class=\"lang-js\">transition: [] // Am empty array.\n</code></pre>\n<p>See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/custom-transition-simple&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> please.</p>\n","default":"['x', 'y']"},"morph":{"type":["boolean"],"description":"<p>Whether to enable morphing animation.</p>\n<p><strong>When morphing animation happen?</strong></p>\n<p>If <code class=\"codespan\">morph</code> is set as <code class=\"codespan\">true</code>, the morphing animation will happen according to the following rule:</p>\n<p>Each time the render process happen, custom series will diff the old data and the new data. If a set of old data items (say, &quot;old set&quot;) are value-equal to a set of new data items (say, &quot;new set&quot;) in name or the specified dimensions (see parameter <a href=\"api.html#echartsInstance.setOption\" target=\"_blank\">transition</a> in <code class=\"codespan\">setOption</code>), we found a pair of sets as transition candidates.</p>\n<p>Three type of transition animation can be performed between the two sets:</p>\n<ul>\n<li>one-to-one: if both the two sets has only one data item.</li>\n<li>one-to-many(separate): if the &quot;old set&quot; has only one data item, and the &quot;new set&quot; has more than one data items.</li>\n<li>many-to-one(combine): if the &quot;old set&quot; has more than one data items, and the &quot;new set&quot; has only one data item.</li>\n</ul>\n<p>Note: we do not support transition animation for the case many-to-many.</p>\n<p>Then custom series find graphic elements that has <code class=\"codespan\">morph: true</code> declared in these two sets, and map them for one to one morphing or combining or separating.</p>\n<p>See examples: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-one-to-one-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-one-to-one-morph</a> and\n<a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-combine-separate-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-combine-separate-morph</a>.</p>\n","default":false},"z2":{"type":["number"],"description":"<p>Define the overlap relationship between graphic elements.</p>\n","default":"undefined"},"name":{"type":["string"],"description":"<p>See <a href=\"#series-custom.renderItem.return_rect.diffChildrenByName\">diffChildrenByName</a>.</p>\n","default":"undefined"},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"x":{"type":["number"],"description":"<p>The x value of the left-top corner of the element in the coordinate system of its parent.</p>\n","default":0},"y":{"type":["number"],"description":"<p>The y value of the left-top corner of the element in the coordinate system of its parent.</p>\n","default":0},"width":{"type":["number"],"description":"<p>The width of the shape of the element.</p>\n","default":0},"height":{"type":["numbr"],"description":"<p>The height of the shape of the element.</p>\n","default":0},"r":{"type":["Array"],"description":"<p>Specify border radius of the rectangular here. Generally, <code class=\"codespan\">r</code> should be <code class=\"codespan\">[topLeftRadius, topRightRadius, BottomRightRadius, bottomLeftRadius]</code>, where each item is a number.</p>\n<p>Abbreviation is enabled, for example:</p>\n<ul>\n<li><code class=\"codespan\">r</code>: <code class=\"codespan\">1</code>         means <code class=\"codespan\">[1, 1, 1, 1]</code></li>\n<li><code class=\"codespan\">r</code>: <code class=\"codespan\">[1]</code>       means <code class=\"codespan\">[1, 1, 1, 1]</code></li>\n<li><code class=\"codespan\">r</code>: <code class=\"codespan\">[1, 2]</code>    means <code class=\"codespan\">[1, 2, 1, 2]</code></li>\n<li><code class=\"codespan\">r</code>: <code class=\"codespan\">[1, 2, 3]</code> means <code class=\"codespan\">[1, 2, 3, 2]</code></li>\n</ul>\n"},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">shape</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `shape` will\n        // have transition animation.\n        transition: &#39;shape&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">style</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `style` will\n        // have transition animation.\n        transition: &#39;style&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of the element.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When it&#39;s highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state, available when <code class=\"codespan\">focus</code> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state, available when <a href=\"#series-custom.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}}}},"return_circle":{"type":["Object"],"description":"<p>Circle element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#series-custom.renderItem.return_image\">image</a>,\n<a href=\"#series-custom.renderItem.return_text\">text</a>,\n<a href=\"#series-custom.renderItem.return_circle\">circle</a>,\n<a href=\"#series-custom.renderItem.return_sector\">sector</a>,\n<a href=\"#series-custom.renderItem.return_ring\">ring</a>,\n<a href=\"#series-custom.renderItem.return_polygon\">polygon</a>,\n<a href=\"#series-custom.renderItem.return_polyline\">polyline</a>,\n<a href=\"#series-custom.renderItem.return_rect\">rect</a>,\n<a href=\"#series-custom.renderItem.return_line\">line</a>,\n<a href=\"#series-custom.renderItem.return_bezierCurve\">bezierCurve</a>,\n<a href=\"#series-custom.renderItem.return_arc\">arc</a>,\n<a href=\"#series-custom.renderItem.return_group\">group</a>,</p>\n","default":"circle"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_circle.x\">x</a> and <a href=\"#series-custom.renderItem.return_circle.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_circle.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_circle.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_circle.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_circle.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_circle.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_circle.x\">x</a> and <a href=\"#series-custom.renderItem.return_circle.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_circle.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_circle.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_circle.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_circle.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_circle.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_circle.x\">x</a> and <a href=\"#series-custom.renderItem.return_circle.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_circle.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_circle.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_circle.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_circle.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_circle.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_circle.x\">x</a> and <a href=\"#series-custom.renderItem.return_circle.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_circle.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_circle.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_circle.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_circle.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_circle.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_circle.x\">x</a> and <a href=\"#series-custom.renderItem.return_circle.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_circle.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_circle.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_circle.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_circle.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_circle.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_circle.x\">x</a> and <a href=\"#series-custom.renderItem.return_circle.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_circle.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_circle.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_circle.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_circle.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_circle.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_circle.x\">x</a> and <a href=\"#series-custom.renderItem.return_circle.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_circle.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_circle.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_circle.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_circle.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_circle.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.</p>\n<p>The properties can only be:</p>\n<ul>\n<li>Transform related properties: <a href=\"#series-custom.renderItem.return_circle.x\"><code class=\"codespan\">&#39;x&#39;</code></a>, <a href=\"#series-custom.renderItem.return_circle.y\"><code class=\"codespan\">&#39;y&#39;</code></a>, <a href=\"#series-custom.renderItem.return_circle.scaleX\"><code class=\"codespan\">&#39;scaleX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_circle.scaleY\"><code class=\"codespan\">&#39;scaleY&#39;</code></a>, <a href=\"#series-custom.renderItem.return_circle.rotation\"><code class=\"codespan\">&#39;rotation&#39;</code></a>, <a href=\"#series-custom.renderItem.return_circle.originX\"><code class=\"codespan\">&#39;originX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_circle.originY\"><code class=\"codespan\">&#39;originY&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      var coord = api.coord([api.value(0), api.value[1]);\n      return {\n          type: &#39;rect&#39;,\n          x: coord[0],\n          y: coord[1],\n          shape: {\n              x: 0,\n              y: 0,\n              width: api.value(2),\n              height: 100\n          },\n          transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;]\n      }\n  }\n</code></pre>\n</li>\n<li>Shortcut to transition all of the properties in <a href=\"#series-custom.renderItem.return_circle.shape\"><code class=\"codespan\">&#39;shape&#39;</code></a>, <a href=\"#series-custom.renderItem.return_circle.style\">&#39;<code class=\"codespan\">style&#39;</code></a>, <a href=\"#series-custom.renderItem.return_circle.extra\"><code class=\"codespan\">&#39;extra&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3)\n          },\n          // Indicate that all props in `shape` will\n          // have transition animation.\n          transition: &#39;shape&#39;,\n      };\n  }\n</code></pre>\n  It is equivalent to:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3),\n              // This usage can only enable part of the\n              // properties transition.\n              transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;, &#39;height&#39;]\n          }\n      };\n  }\n</code></pre>\n</li>\n</ul>\n<p>By default, <a href=\"#series-custom.renderItem.return_circle.x\"><code class=\"codespan\">&#39;x&#39;</code></a> and <a href=\"#series-custom.renderItem.return_circle.y\"><code class=\"codespan\">&#39;y&#39;</code></a> are transitioned. If you want to disable the default transition, just set it as:</p>\n<pre><code class=\"lang-js\">transition: [] // Am empty array.\n</code></pre>\n<p>See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/custom-transition-simple&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> please.</p>\n","default":"['x', 'y']"},"morph":{"type":["boolean"],"description":"<p>Whether to enable morphing animation.</p>\n<p><strong>When morphing animation happen?</strong></p>\n<p>If <code class=\"codespan\">morph</code> is set as <code class=\"codespan\">true</code>, the morphing animation will happen according to the following rule:</p>\n<p>Each time the render process happen, custom series will diff the old data and the new data. If a set of old data items (say, &quot;old set&quot;) are value-equal to a set of new data items (say, &quot;new set&quot;) in name or the specified dimensions (see parameter <a href=\"api.html#echartsInstance.setOption\" target=\"_blank\">transition</a> in <code class=\"codespan\">setOption</code>), we found a pair of sets as transition candidates.</p>\n<p>Three type of transition animation can be performed between the two sets:</p>\n<ul>\n<li>one-to-one: if both the two sets has only one data item.</li>\n<li>one-to-many(separate): if the &quot;old set&quot; has only one data item, and the &quot;new set&quot; has more than one data items.</li>\n<li>many-to-one(combine): if the &quot;old set&quot; has more than one data items, and the &quot;new set&quot; has only one data item.</li>\n</ul>\n<p>Note: we do not support transition animation for the case many-to-many.</p>\n<p>Then custom series find graphic elements that has <code class=\"codespan\">morph: true</code> declared in these two sets, and map them for one to one morphing or combining or separating.</p>\n<p>See examples: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-one-to-one-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-one-to-one-morph</a> and\n<a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-combine-separate-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-combine-separate-morph</a>.</p>\n","default":false},"z2":{"type":["number"],"description":"<p>Define the overlap relationship between graphic elements.</p>\n","default":"undefined"},"name":{"type":["string"],"description":"<p>See <a href=\"#series-custom.renderItem.return_circle.diffChildrenByName\">diffChildrenByName</a>.</p>\n","default":"undefined"},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"cx":{"type":["number"],"description":"<p>The x value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"cy":{"type":["numbr"],"description":"<p>The y value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"r":{"type":["number"],"description":"<p>Outside radius.</p>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">shape</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `shape` will\n        // have transition animation.\n        transition: &#39;shape&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">style</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `style` will\n        // have transition animation.\n        transition: &#39;style&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of the element.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When it&#39;s highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state, available when <code class=\"codespan\">focus</code> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state, available when <a href=\"#series-custom.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}}}},"return_ring":{"type":["Object"],"description":"<p>Ring element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#series-custom.renderItem.return_image\">image</a>,\n<a href=\"#series-custom.renderItem.return_text\">text</a>,\n<a href=\"#series-custom.renderItem.return_circle\">circle</a>,\n<a href=\"#series-custom.renderItem.return_sector\">sector</a>,\n<a href=\"#series-custom.renderItem.return_ring\">ring</a>,\n<a href=\"#series-custom.renderItem.return_polygon\">polygon</a>,\n<a href=\"#series-custom.renderItem.return_polyline\">polyline</a>,\n<a href=\"#series-custom.renderItem.return_rect\">rect</a>,\n<a href=\"#series-custom.renderItem.return_line\">line</a>,\n<a href=\"#series-custom.renderItem.return_bezierCurve\">bezierCurve</a>,\n<a href=\"#series-custom.renderItem.return_arc\">arc</a>,\n<a href=\"#series-custom.renderItem.return_group\">group</a>,</p>\n","default":"ring"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_ring.x\">x</a> and <a href=\"#series-custom.renderItem.return_ring.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_ring.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_ring.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_ring.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_ring.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_ring.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_ring.x\">x</a> and <a href=\"#series-custom.renderItem.return_ring.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_ring.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_ring.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_ring.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_ring.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_ring.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_ring.x\">x</a> and <a href=\"#series-custom.renderItem.return_ring.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_ring.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_ring.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_ring.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_ring.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_ring.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_ring.x\">x</a> and <a href=\"#series-custom.renderItem.return_ring.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_ring.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_ring.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_ring.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_ring.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_ring.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_ring.x\">x</a> and <a href=\"#series-custom.renderItem.return_ring.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_ring.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_ring.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_ring.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_ring.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_ring.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_ring.x\">x</a> and <a href=\"#series-custom.renderItem.return_ring.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_ring.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_ring.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_ring.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_ring.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_ring.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_ring.x\">x</a> and <a href=\"#series-custom.renderItem.return_ring.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_ring.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_ring.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_ring.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_ring.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_ring.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.</p>\n<p>The properties can only be:</p>\n<ul>\n<li>Transform related properties: <a href=\"#series-custom.renderItem.return_ring.x\"><code class=\"codespan\">&#39;x&#39;</code></a>, <a href=\"#series-custom.renderItem.return_ring.y\"><code class=\"codespan\">&#39;y&#39;</code></a>, <a href=\"#series-custom.renderItem.return_ring.scaleX\"><code class=\"codespan\">&#39;scaleX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_ring.scaleY\"><code class=\"codespan\">&#39;scaleY&#39;</code></a>, <a href=\"#series-custom.renderItem.return_ring.rotation\"><code class=\"codespan\">&#39;rotation&#39;</code></a>, <a href=\"#series-custom.renderItem.return_ring.originX\"><code class=\"codespan\">&#39;originX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_ring.originY\"><code class=\"codespan\">&#39;originY&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      var coord = api.coord([api.value(0), api.value[1]);\n      return {\n          type: &#39;rect&#39;,\n          x: coord[0],\n          y: coord[1],\n          shape: {\n              x: 0,\n              y: 0,\n              width: api.value(2),\n              height: 100\n          },\n          transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;]\n      }\n  }\n</code></pre>\n</li>\n<li>Shortcut to transition all of the properties in <a href=\"#series-custom.renderItem.return_ring.shape\"><code class=\"codespan\">&#39;shape&#39;</code></a>, <a href=\"#series-custom.renderItem.return_ring.style\">&#39;<code class=\"codespan\">style&#39;</code></a>, <a href=\"#series-custom.renderItem.return_ring.extra\"><code class=\"codespan\">&#39;extra&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3)\n          },\n          // Indicate that all props in `shape` will\n          // have transition animation.\n          transition: &#39;shape&#39;,\n      };\n  }\n</code></pre>\n  It is equivalent to:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3),\n              // This usage can only enable part of the\n              // properties transition.\n              transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;, &#39;height&#39;]\n          }\n      };\n  }\n</code></pre>\n</li>\n</ul>\n<p>By default, <a href=\"#series-custom.renderItem.return_ring.x\"><code class=\"codespan\">&#39;x&#39;</code></a> and <a href=\"#series-custom.renderItem.return_ring.y\"><code class=\"codespan\">&#39;y&#39;</code></a> are transitioned. If you want to disable the default transition, just set it as:</p>\n<pre><code class=\"lang-js\">transition: [] // Am empty array.\n</code></pre>\n<p>See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/custom-transition-simple&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> please.</p>\n","default":"['x', 'y']"},"morph":{"type":["boolean"],"description":"<p>Whether to enable morphing animation.</p>\n<p><strong>When morphing animation happen?</strong></p>\n<p>If <code class=\"codespan\">morph</code> is set as <code class=\"codespan\">true</code>, the morphing animation will happen according to the following rule:</p>\n<p>Each time the render process happen, custom series will diff the old data and the new data. If a set of old data items (say, &quot;old set&quot;) are value-equal to a set of new data items (say, &quot;new set&quot;) in name or the specified dimensions (see parameter <a href=\"api.html#echartsInstance.setOption\" target=\"_blank\">transition</a> in <code class=\"codespan\">setOption</code>), we found a pair of sets as transition candidates.</p>\n<p>Three type of transition animation can be performed between the two sets:</p>\n<ul>\n<li>one-to-one: if both the two sets has only one data item.</li>\n<li>one-to-many(separate): if the &quot;old set&quot; has only one data item, and the &quot;new set&quot; has more than one data items.</li>\n<li>many-to-one(combine): if the &quot;old set&quot; has more than one data items, and the &quot;new set&quot; has only one data item.</li>\n</ul>\n<p>Note: we do not support transition animation for the case many-to-many.</p>\n<p>Then custom series find graphic elements that has <code class=\"codespan\">morph: true</code> declared in these two sets, and map them for one to one morphing or combining or separating.</p>\n<p>See examples: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-one-to-one-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-one-to-one-morph</a> and\n<a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-combine-separate-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-combine-separate-morph</a>.</p>\n","default":false},"z2":{"type":["number"],"description":"<p>Define the overlap relationship between graphic elements.</p>\n","default":"undefined"},"name":{"type":["string"],"description":"<p>See <a href=\"#series-custom.renderItem.return_ring.diffChildrenByName\">diffChildrenByName</a>.</p>\n","default":"undefined"},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"cx":{"type":["number"],"description":"<p>The x value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"cy":{"type":["numbr"],"description":"<p>The y value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"r":{"type":["number"],"description":"<p>Outside radius.</p>\n","default":0},"r0":{"type":["number"],"description":"<p>Inside radius.</p>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">shape</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `shape` will\n        // have transition animation.\n        transition: &#39;shape&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">style</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `style` will\n        // have transition animation.\n        transition: &#39;style&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of the element.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When it&#39;s highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state, available when <code class=\"codespan\">focus</code> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state, available when <a href=\"#series-custom.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}}}},"return_sector":{"type":["Object"],"description":"<p>Sector element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#series-custom.renderItem.return_image\">image</a>,\n<a href=\"#series-custom.renderItem.return_text\">text</a>,\n<a href=\"#series-custom.renderItem.return_circle\">circle</a>,\n<a href=\"#series-custom.renderItem.return_sector\">sector</a>,\n<a href=\"#series-custom.renderItem.return_ring\">ring</a>,\n<a href=\"#series-custom.renderItem.return_polygon\">polygon</a>,\n<a href=\"#series-custom.renderItem.return_polyline\">polyline</a>,\n<a href=\"#series-custom.renderItem.return_rect\">rect</a>,\n<a href=\"#series-custom.renderItem.return_line\">line</a>,\n<a href=\"#series-custom.renderItem.return_bezierCurve\">bezierCurve</a>,\n<a href=\"#series-custom.renderItem.return_arc\">arc</a>,\n<a href=\"#series-custom.renderItem.return_group\">group</a>,</p>\n","default":"sector"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_sector.x\">x</a> and <a href=\"#series-custom.renderItem.return_sector.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_sector.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_sector.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_sector.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_sector.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_sector.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_sector.x\">x</a> and <a href=\"#series-custom.renderItem.return_sector.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_sector.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_sector.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_sector.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_sector.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_sector.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_sector.x\">x</a> and <a href=\"#series-custom.renderItem.return_sector.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_sector.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_sector.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_sector.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_sector.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_sector.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_sector.x\">x</a> and <a href=\"#series-custom.renderItem.return_sector.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_sector.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_sector.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_sector.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_sector.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_sector.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_sector.x\">x</a> and <a href=\"#series-custom.renderItem.return_sector.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_sector.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_sector.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_sector.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_sector.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_sector.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_sector.x\">x</a> and <a href=\"#series-custom.renderItem.return_sector.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_sector.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_sector.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_sector.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_sector.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_sector.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_sector.x\">x</a> and <a href=\"#series-custom.renderItem.return_sector.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_sector.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_sector.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_sector.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_sector.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_sector.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.</p>\n<p>The properties can only be:</p>\n<ul>\n<li>Transform related properties: <a href=\"#series-custom.renderItem.return_sector.x\"><code class=\"codespan\">&#39;x&#39;</code></a>, <a href=\"#series-custom.renderItem.return_sector.y\"><code class=\"codespan\">&#39;y&#39;</code></a>, <a href=\"#series-custom.renderItem.return_sector.scaleX\"><code class=\"codespan\">&#39;scaleX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_sector.scaleY\"><code class=\"codespan\">&#39;scaleY&#39;</code></a>, <a href=\"#series-custom.renderItem.return_sector.rotation\"><code class=\"codespan\">&#39;rotation&#39;</code></a>, <a href=\"#series-custom.renderItem.return_sector.originX\"><code class=\"codespan\">&#39;originX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_sector.originY\"><code class=\"codespan\">&#39;originY&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      var coord = api.coord([api.value(0), api.value[1]);\n      return {\n          type: &#39;rect&#39;,\n          x: coord[0],\n          y: coord[1],\n          shape: {\n              x: 0,\n              y: 0,\n              width: api.value(2),\n              height: 100\n          },\n          transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;]\n      }\n  }\n</code></pre>\n</li>\n<li>Shortcut to transition all of the properties in <a href=\"#series-custom.renderItem.return_sector.shape\"><code class=\"codespan\">&#39;shape&#39;</code></a>, <a href=\"#series-custom.renderItem.return_sector.style\">&#39;<code class=\"codespan\">style&#39;</code></a>, <a href=\"#series-custom.renderItem.return_sector.extra\"><code class=\"codespan\">&#39;extra&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3)\n          },\n          // Indicate that all props in `shape` will\n          // have transition animation.\n          transition: &#39;shape&#39;,\n      };\n  }\n</code></pre>\n  It is equivalent to:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3),\n              // This usage can only enable part of the\n              // properties transition.\n              transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;, &#39;height&#39;]\n          }\n      };\n  }\n</code></pre>\n</li>\n</ul>\n<p>By default, <a href=\"#series-custom.renderItem.return_sector.x\"><code class=\"codespan\">&#39;x&#39;</code></a> and <a href=\"#series-custom.renderItem.return_sector.y\"><code class=\"codespan\">&#39;y&#39;</code></a> are transitioned. If you want to disable the default transition, just set it as:</p>\n<pre><code class=\"lang-js\">transition: [] // Am empty array.\n</code></pre>\n<p>See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/custom-transition-simple&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> please.</p>\n","default":"['x', 'y']"},"morph":{"type":["boolean"],"description":"<p>Whether to enable morphing animation.</p>\n<p><strong>When morphing animation happen?</strong></p>\n<p>If <code class=\"codespan\">morph</code> is set as <code class=\"codespan\">true</code>, the morphing animation will happen according to the following rule:</p>\n<p>Each time the render process happen, custom series will diff the old data and the new data. If a set of old data items (say, &quot;old set&quot;) are value-equal to a set of new data items (say, &quot;new set&quot;) in name or the specified dimensions (see parameter <a href=\"api.html#echartsInstance.setOption\" target=\"_blank\">transition</a> in <code class=\"codespan\">setOption</code>), we found a pair of sets as transition candidates.</p>\n<p>Three type of transition animation can be performed between the two sets:</p>\n<ul>\n<li>one-to-one: if both the two sets has only one data item.</li>\n<li>one-to-many(separate): if the &quot;old set&quot; has only one data item, and the &quot;new set&quot; has more than one data items.</li>\n<li>many-to-one(combine): if the &quot;old set&quot; has more than one data items, and the &quot;new set&quot; has only one data item.</li>\n</ul>\n<p>Note: we do not support transition animation for the case many-to-many.</p>\n<p>Then custom series find graphic elements that has <code class=\"codespan\">morph: true</code> declared in these two sets, and map them for one to one morphing or combining or separating.</p>\n<p>See examples: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-one-to-one-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-one-to-one-morph</a> and\n<a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-combine-separate-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-combine-separate-morph</a>.</p>\n","default":false},"z2":{"type":["number"],"description":"<p>Define the overlap relationship between graphic elements.</p>\n","default":"undefined"},"name":{"type":["string"],"description":"<p>See <a href=\"#series-custom.renderItem.return_sector.diffChildrenByName\">diffChildrenByName</a>.</p>\n","default":"undefined"},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"cx":{"type":["number"],"description":"<p>The x value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"cy":{"type":["numbr"],"description":"<p>The y value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"r":{"type":["number"],"description":"<p>Outside radius.</p>\n","default":0},"r0":{"type":["number"],"description":"<p>Inside radius.</p>\n","default":0},"startAngle":{"type":["number"],"description":"<p>start angle, in radian.</p>\n","default":0},"endAngle":{"type":["number"],"description":"<p>end angle, in radian.</p>\n","default":"Math.PI * 2"},"clockwise":{"type":["boolean"],"description":"<p>Whether draw clockwise.</p>\n","default":true},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">shape</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `shape` will\n        // have transition animation.\n        transition: &#39;shape&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">style</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `style` will\n        // have transition animation.\n        transition: &#39;style&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of the element.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When it&#39;s highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state, available when <code class=\"codespan\">focus</code> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state, available when <a href=\"#series-custom.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}}}},"return_arc":{"type":["Object"],"description":"<p>Arc element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#series-custom.renderItem.return_image\">image</a>,\n<a href=\"#series-custom.renderItem.return_text\">text</a>,\n<a href=\"#series-custom.renderItem.return_circle\">circle</a>,\n<a href=\"#series-custom.renderItem.return_sector\">sector</a>,\n<a href=\"#series-custom.renderItem.return_ring\">ring</a>,\n<a href=\"#series-custom.renderItem.return_polygon\">polygon</a>,\n<a href=\"#series-custom.renderItem.return_polyline\">polyline</a>,\n<a href=\"#series-custom.renderItem.return_rect\">rect</a>,\n<a href=\"#series-custom.renderItem.return_line\">line</a>,\n<a href=\"#series-custom.renderItem.return_bezierCurve\">bezierCurve</a>,\n<a href=\"#series-custom.renderItem.return_arc\">arc</a>,\n<a href=\"#series-custom.renderItem.return_group\">group</a>,</p>\n","default":"arc"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_arc.x\">x</a> and <a href=\"#series-custom.renderItem.return_arc.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_arc.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_arc.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_arc.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_arc.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_arc.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_arc.x\">x</a> and <a href=\"#series-custom.renderItem.return_arc.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_arc.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_arc.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_arc.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_arc.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_arc.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_arc.x\">x</a> and <a href=\"#series-custom.renderItem.return_arc.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_arc.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_arc.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_arc.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_arc.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_arc.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_arc.x\">x</a> and <a href=\"#series-custom.renderItem.return_arc.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_arc.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_arc.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_arc.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_arc.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_arc.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_arc.x\">x</a> and <a href=\"#series-custom.renderItem.return_arc.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_arc.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_arc.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_arc.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_arc.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_arc.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_arc.x\">x</a> and <a href=\"#series-custom.renderItem.return_arc.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_arc.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_arc.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_arc.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_arc.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_arc.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_arc.x\">x</a> and <a href=\"#series-custom.renderItem.return_arc.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_arc.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_arc.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_arc.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_arc.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_arc.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.</p>\n<p>The properties can only be:</p>\n<ul>\n<li>Transform related properties: <a href=\"#series-custom.renderItem.return_arc.x\"><code class=\"codespan\">&#39;x&#39;</code></a>, <a href=\"#series-custom.renderItem.return_arc.y\"><code class=\"codespan\">&#39;y&#39;</code></a>, <a href=\"#series-custom.renderItem.return_arc.scaleX\"><code class=\"codespan\">&#39;scaleX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_arc.scaleY\"><code class=\"codespan\">&#39;scaleY&#39;</code></a>, <a href=\"#series-custom.renderItem.return_arc.rotation\"><code class=\"codespan\">&#39;rotation&#39;</code></a>, <a href=\"#series-custom.renderItem.return_arc.originX\"><code class=\"codespan\">&#39;originX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_arc.originY\"><code class=\"codespan\">&#39;originY&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      var coord = api.coord([api.value(0), api.value[1]);\n      return {\n          type: &#39;rect&#39;,\n          x: coord[0],\n          y: coord[1],\n          shape: {\n              x: 0,\n              y: 0,\n              width: api.value(2),\n              height: 100\n          },\n          transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;]\n      }\n  }\n</code></pre>\n</li>\n<li>Shortcut to transition all of the properties in <a href=\"#series-custom.renderItem.return_arc.shape\"><code class=\"codespan\">&#39;shape&#39;</code></a>, <a href=\"#series-custom.renderItem.return_arc.style\">&#39;<code class=\"codespan\">style&#39;</code></a>, <a href=\"#series-custom.renderItem.return_arc.extra\"><code class=\"codespan\">&#39;extra&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3)\n          },\n          // Indicate that all props in `shape` will\n          // have transition animation.\n          transition: &#39;shape&#39;,\n      };\n  }\n</code></pre>\n  It is equivalent to:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3),\n              // This usage can only enable part of the\n              // properties transition.\n              transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;, &#39;height&#39;]\n          }\n      };\n  }\n</code></pre>\n</li>\n</ul>\n<p>By default, <a href=\"#series-custom.renderItem.return_arc.x\"><code class=\"codespan\">&#39;x&#39;</code></a> and <a href=\"#series-custom.renderItem.return_arc.y\"><code class=\"codespan\">&#39;y&#39;</code></a> are transitioned. If you want to disable the default transition, just set it as:</p>\n<pre><code class=\"lang-js\">transition: [] // Am empty array.\n</code></pre>\n<p>See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/custom-transition-simple&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> please.</p>\n","default":"['x', 'y']"},"morph":{"type":["boolean"],"description":"<p>Whether to enable morphing animation.</p>\n<p><strong>When morphing animation happen?</strong></p>\n<p>If <code class=\"codespan\">morph</code> is set as <code class=\"codespan\">true</code>, the morphing animation will happen according to the following rule:</p>\n<p>Each time the render process happen, custom series will diff the old data and the new data. If a set of old data items (say, &quot;old set&quot;) are value-equal to a set of new data items (say, &quot;new set&quot;) in name or the specified dimensions (see parameter <a href=\"api.html#echartsInstance.setOption\" target=\"_blank\">transition</a> in <code class=\"codespan\">setOption</code>), we found a pair of sets as transition candidates.</p>\n<p>Three type of transition animation can be performed between the two sets:</p>\n<ul>\n<li>one-to-one: if both the two sets has only one data item.</li>\n<li>one-to-many(separate): if the &quot;old set&quot; has only one data item, and the &quot;new set&quot; has more than one data items.</li>\n<li>many-to-one(combine): if the &quot;old set&quot; has more than one data items, and the &quot;new set&quot; has only one data item.</li>\n</ul>\n<p>Note: we do not support transition animation for the case many-to-many.</p>\n<p>Then custom series find graphic elements that has <code class=\"codespan\">morph: true</code> declared in these two sets, and map them for one to one morphing or combining or separating.</p>\n<p>See examples: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-one-to-one-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-one-to-one-morph</a> and\n<a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-combine-separate-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-combine-separate-morph</a>.</p>\n","default":false},"z2":{"type":["number"],"description":"<p>Define the overlap relationship between graphic elements.</p>\n","default":"undefined"},"name":{"type":["string"],"description":"<p>See <a href=\"#series-custom.renderItem.return_arc.diffChildrenByName\">diffChildrenByName</a>.</p>\n","default":"undefined"},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"cx":{"type":["number"],"description":"<p>The x value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"cy":{"type":["numbr"],"description":"<p>The y value of the center of the element in the coordinate system of its parent.</p>\n","default":0},"r":{"type":["number"],"description":"<p>Outside radius.</p>\n","default":0},"r0":{"type":["number"],"description":"<p>Inside radius.</p>\n","default":0},"startAngle":{"type":["number"],"description":"<p>start angle, in radian.</p>\n","default":0},"endAngle":{"type":["number"],"description":"<p>end angle, in radian.</p>\n","default":"Math.PI * 2"},"clockwise":{"type":["boolean"],"description":"<p>Whether draw clockwise.</p>\n","default":true},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">shape</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `shape` will\n        // have transition animation.\n        transition: &#39;shape&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":null},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":"\"#000\""},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":1},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">style</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `style` will\n        // have transition animation.\n        transition: &#39;style&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of the element.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When it&#39;s highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state, available when <code class=\"codespan\">focus</code> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state, available when <a href=\"#series-custom.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}}}},"return_polygon":{"type":["Object"],"description":"<p>Polygon element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#series-custom.renderItem.return_image\">image</a>,\n<a href=\"#series-custom.renderItem.return_text\">text</a>,\n<a href=\"#series-custom.renderItem.return_circle\">circle</a>,\n<a href=\"#series-custom.renderItem.return_sector\">sector</a>,\n<a href=\"#series-custom.renderItem.return_ring\">ring</a>,\n<a href=\"#series-custom.renderItem.return_polygon\">polygon</a>,\n<a href=\"#series-custom.renderItem.return_polyline\">polyline</a>,\n<a href=\"#series-custom.renderItem.return_rect\">rect</a>,\n<a href=\"#series-custom.renderItem.return_line\">line</a>,\n<a href=\"#series-custom.renderItem.return_bezierCurve\">bezierCurve</a>,\n<a href=\"#series-custom.renderItem.return_arc\">arc</a>,\n<a href=\"#series-custom.renderItem.return_group\">group</a>,</p>\n","default":"polygon"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_polygon.x\">x</a> and <a href=\"#series-custom.renderItem.return_polygon.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_polygon.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_polygon.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_polygon.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_polygon.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_polygon.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_polygon.x\">x</a> and <a href=\"#series-custom.renderItem.return_polygon.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_polygon.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_polygon.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_polygon.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_polygon.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_polygon.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_polygon.x\">x</a> and <a href=\"#series-custom.renderItem.return_polygon.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_polygon.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_polygon.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_polygon.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_polygon.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_polygon.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_polygon.x\">x</a> and <a href=\"#series-custom.renderItem.return_polygon.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_polygon.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_polygon.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_polygon.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_polygon.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_polygon.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_polygon.x\">x</a> and <a href=\"#series-custom.renderItem.return_polygon.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_polygon.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_polygon.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_polygon.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_polygon.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_polygon.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_polygon.x\">x</a> and <a href=\"#series-custom.renderItem.return_polygon.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_polygon.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_polygon.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_polygon.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_polygon.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_polygon.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_polygon.x\">x</a> and <a href=\"#series-custom.renderItem.return_polygon.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_polygon.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_polygon.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_polygon.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_polygon.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_polygon.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.</p>\n<p>The properties can only be:</p>\n<ul>\n<li>Transform related properties: <a href=\"#series-custom.renderItem.return_polygon.x\"><code class=\"codespan\">&#39;x&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polygon.y\"><code class=\"codespan\">&#39;y&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polygon.scaleX\"><code class=\"codespan\">&#39;scaleX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polygon.scaleY\"><code class=\"codespan\">&#39;scaleY&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polygon.rotation\"><code class=\"codespan\">&#39;rotation&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polygon.originX\"><code class=\"codespan\">&#39;originX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polygon.originY\"><code class=\"codespan\">&#39;originY&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      var coord = api.coord([api.value(0), api.value[1]);\n      return {\n          type: &#39;rect&#39;,\n          x: coord[0],\n          y: coord[1],\n          shape: {\n              x: 0,\n              y: 0,\n              width: api.value(2),\n              height: 100\n          },\n          transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;]\n      }\n  }\n</code></pre>\n</li>\n<li>Shortcut to transition all of the properties in <a href=\"#series-custom.renderItem.return_polygon.shape\"><code class=\"codespan\">&#39;shape&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polygon.style\">&#39;<code class=\"codespan\">style&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polygon.extra\"><code class=\"codespan\">&#39;extra&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3)\n          },\n          // Indicate that all props in `shape` will\n          // have transition animation.\n          transition: &#39;shape&#39;,\n      };\n  }\n</code></pre>\n  It is equivalent to:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3),\n              // This usage can only enable part of the\n              // properties transition.\n              transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;, &#39;height&#39;]\n          }\n      };\n  }\n</code></pre>\n</li>\n</ul>\n<p>By default, <a href=\"#series-custom.renderItem.return_polygon.x\"><code class=\"codespan\">&#39;x&#39;</code></a> and <a href=\"#series-custom.renderItem.return_polygon.y\"><code class=\"codespan\">&#39;y&#39;</code></a> are transitioned. If you want to disable the default transition, just set it as:</p>\n<pre><code class=\"lang-js\">transition: [] // Am empty array.\n</code></pre>\n<p>See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/custom-transition-simple&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> please.</p>\n","default":"['x', 'y']"},"morph":{"type":["boolean"],"description":"<p>Whether to enable morphing animation.</p>\n<p><strong>When morphing animation happen?</strong></p>\n<p>If <code class=\"codespan\">morph</code> is set as <code class=\"codespan\">true</code>, the morphing animation will happen according to the following rule:</p>\n<p>Each time the render process happen, custom series will diff the old data and the new data. If a set of old data items (say, &quot;old set&quot;) are value-equal to a set of new data items (say, &quot;new set&quot;) in name or the specified dimensions (see parameter <a href=\"api.html#echartsInstance.setOption\" target=\"_blank\">transition</a> in <code class=\"codespan\">setOption</code>), we found a pair of sets as transition candidates.</p>\n<p>Three type of transition animation can be performed between the two sets:</p>\n<ul>\n<li>one-to-one: if both the two sets has only one data item.</li>\n<li>one-to-many(separate): if the &quot;old set&quot; has only one data item, and the &quot;new set&quot; has more than one data items.</li>\n<li>many-to-one(combine): if the &quot;old set&quot; has more than one data items, and the &quot;new set&quot; has only one data item.</li>\n</ul>\n<p>Note: we do not support transition animation for the case many-to-many.</p>\n<p>Then custom series find graphic elements that has <code class=\"codespan\">morph: true</code> declared in these two sets, and map them for one to one morphing or combining or separating.</p>\n<p>See examples: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-one-to-one-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-one-to-one-morph</a> and\n<a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-combine-separate-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-combine-separate-morph</a>.</p>\n","default":false},"z2":{"type":["number"],"description":"<p>Define the overlap relationship between graphic elements.</p>\n","default":"undefined"},"name":{"type":["string"],"description":"<p>See <a href=\"#series-custom.renderItem.return_polygon.diffChildrenByName\">diffChildrenByName</a>.</p>\n","default":"undefined"},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"points":{"type":["Array"],"description":"<p>A list of points, which defines the shape, like <code class=\"codespan\">[[22, 44], [44, 55], [11, 44], ...]</code>.</p>\n"},"smooth":{"type":["number","string"],"description":"<p>Whether smooth the line.</p>\n<ul>\n<li>If the value is number, bezier interpolation is used, and the value specified the level of smooth, which is in the range of <code class=\"codespan\">[0, 1]</code>.</li>\n<li>If the value is <code class=\"codespan\">&#39;spline&#39;</code>, Catmull-Rom spline interpolation is used.</li>\n</ul>\n","default":"undefined"},"smoothConstraint":{"type":["boolean"],"description":"<p>Whether prevent the smooth process cause the line out of the bounding box.</p>\n<p>Only works when <code class=\"codespan\">smooth</code> is <code class=\"codespan\">number</code> (bezier smooth).</p>\n","default":false},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">shape</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `shape` will\n        // have transition animation.\n        transition: &#39;shape&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">style</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `style` will\n        // have transition animation.\n        transition: &#39;style&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of the element.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When it&#39;s highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state, available when <code class=\"codespan\">focus</code> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state, available when <a href=\"#series-custom.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}}}},"return_polyline":{"type":["Object"],"description":"<p>Polyline element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#series-custom.renderItem.return_image\">image</a>,\n<a href=\"#series-custom.renderItem.return_text\">text</a>,\n<a href=\"#series-custom.renderItem.return_circle\">circle</a>,\n<a href=\"#series-custom.renderItem.return_sector\">sector</a>,\n<a href=\"#series-custom.renderItem.return_ring\">ring</a>,\n<a href=\"#series-custom.renderItem.return_polygon\">polygon</a>,\n<a href=\"#series-custom.renderItem.return_polyline\">polyline</a>,\n<a href=\"#series-custom.renderItem.return_rect\">rect</a>,\n<a href=\"#series-custom.renderItem.return_line\">line</a>,\n<a href=\"#series-custom.renderItem.return_bezierCurve\">bezierCurve</a>,\n<a href=\"#series-custom.renderItem.return_arc\">arc</a>,\n<a href=\"#series-custom.renderItem.return_group\">group</a>,</p>\n","default":"polyline"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_polyline.x\">x</a> and <a href=\"#series-custom.renderItem.return_polyline.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_polyline.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_polyline.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_polyline.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_polyline.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_polyline.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_polyline.x\">x</a> and <a href=\"#series-custom.renderItem.return_polyline.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_polyline.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_polyline.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_polyline.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_polyline.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_polyline.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_polyline.x\">x</a> and <a href=\"#series-custom.renderItem.return_polyline.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_polyline.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_polyline.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_polyline.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_polyline.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_polyline.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_polyline.x\">x</a> and <a href=\"#series-custom.renderItem.return_polyline.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_polyline.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_polyline.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_polyline.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_polyline.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_polyline.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_polyline.x\">x</a> and <a href=\"#series-custom.renderItem.return_polyline.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_polyline.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_polyline.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_polyline.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_polyline.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_polyline.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_polyline.x\">x</a> and <a href=\"#series-custom.renderItem.return_polyline.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_polyline.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_polyline.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_polyline.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_polyline.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_polyline.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_polyline.x\">x</a> and <a href=\"#series-custom.renderItem.return_polyline.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_polyline.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_polyline.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_polyline.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_polyline.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_polyline.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.</p>\n<p>The properties can only be:</p>\n<ul>\n<li>Transform related properties: <a href=\"#series-custom.renderItem.return_polyline.x\"><code class=\"codespan\">&#39;x&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polyline.y\"><code class=\"codespan\">&#39;y&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polyline.scaleX\"><code class=\"codespan\">&#39;scaleX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polyline.scaleY\"><code class=\"codespan\">&#39;scaleY&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polyline.rotation\"><code class=\"codespan\">&#39;rotation&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polyline.originX\"><code class=\"codespan\">&#39;originX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polyline.originY\"><code class=\"codespan\">&#39;originY&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      var coord = api.coord([api.value(0), api.value[1]);\n      return {\n          type: &#39;rect&#39;,\n          x: coord[0],\n          y: coord[1],\n          shape: {\n              x: 0,\n              y: 0,\n              width: api.value(2),\n              height: 100\n          },\n          transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;]\n      }\n  }\n</code></pre>\n</li>\n<li>Shortcut to transition all of the properties in <a href=\"#series-custom.renderItem.return_polyline.shape\"><code class=\"codespan\">&#39;shape&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polyline.style\">&#39;<code class=\"codespan\">style&#39;</code></a>, <a href=\"#series-custom.renderItem.return_polyline.extra\"><code class=\"codespan\">&#39;extra&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3)\n          },\n          // Indicate that all props in `shape` will\n          // have transition animation.\n          transition: &#39;shape&#39;,\n      };\n  }\n</code></pre>\n  It is equivalent to:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3),\n              // This usage can only enable part of the\n              // properties transition.\n              transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;, &#39;height&#39;]\n          }\n      };\n  }\n</code></pre>\n</li>\n</ul>\n<p>By default, <a href=\"#series-custom.renderItem.return_polyline.x\"><code class=\"codespan\">&#39;x&#39;</code></a> and <a href=\"#series-custom.renderItem.return_polyline.y\"><code class=\"codespan\">&#39;y&#39;</code></a> are transitioned. If you want to disable the default transition, just set it as:</p>\n<pre><code class=\"lang-js\">transition: [] // Am empty array.\n</code></pre>\n<p>See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/custom-transition-simple&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> please.</p>\n","default":"['x', 'y']"},"morph":{"type":["boolean"],"description":"<p>Whether to enable morphing animation.</p>\n<p><strong>When morphing animation happen?</strong></p>\n<p>If <code class=\"codespan\">morph</code> is set as <code class=\"codespan\">true</code>, the morphing animation will happen according to the following rule:</p>\n<p>Each time the render process happen, custom series will diff the old data and the new data. If a set of old data items (say, &quot;old set&quot;) are value-equal to a set of new data items (say, &quot;new set&quot;) in name or the specified dimensions (see parameter <a href=\"api.html#echartsInstance.setOption\" target=\"_blank\">transition</a> in <code class=\"codespan\">setOption</code>), we found a pair of sets as transition candidates.</p>\n<p>Three type of transition animation can be performed between the two sets:</p>\n<ul>\n<li>one-to-one: if both the two sets has only one data item.</li>\n<li>one-to-many(separate): if the &quot;old set&quot; has only one data item, and the &quot;new set&quot; has more than one data items.</li>\n<li>many-to-one(combine): if the &quot;old set&quot; has more than one data items, and the &quot;new set&quot; has only one data item.</li>\n</ul>\n<p>Note: we do not support transition animation for the case many-to-many.</p>\n<p>Then custom series find graphic elements that has <code class=\"codespan\">morph: true</code> declared in these two sets, and map them for one to one morphing or combining or separating.</p>\n<p>See examples: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-one-to-one-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-one-to-one-morph</a> and\n<a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-combine-separate-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-combine-separate-morph</a>.</p>\n","default":false},"z2":{"type":["number"],"description":"<p>Define the overlap relationship between graphic elements.</p>\n","default":"undefined"},"name":{"type":["string"],"description":"<p>See <a href=\"#series-custom.renderItem.return_polyline.diffChildrenByName\">diffChildrenByName</a>.</p>\n","default":"undefined"},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"points":{"type":["Array"],"description":"<p>A list of points, which defines the shape, like <code class=\"codespan\">[[22, 44], [44, 55], [11, 44], ...]</code>.</p>\n"},"smooth":{"type":["number","string"],"description":"<p>Whether smooth the line.</p>\n<ul>\n<li>If the value is number, bezier interpolation is used, and the value specified the level of smooth, which is in the range of <code class=\"codespan\">[0, 1]</code>.</li>\n<li>If the value is <code class=\"codespan\">&#39;spline&#39;</code>, Catmull-Rom spline interpolation is used.</li>\n</ul>\n","default":"undefined"},"smoothConstraint":{"type":["boolean"],"description":"<p>Whether prevent the smooth process cause the line out of the bounding box.</p>\n<p>Only works when <code class=\"codespan\">smooth</code> is <code class=\"codespan\">number</code> (bezier smooth).</p>\n","default":false},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">shape</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `shape` will\n        // have transition animation.\n        transition: &#39;shape&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":null},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":"\"#000\""},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":5},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">style</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `style` will\n        // have transition animation.\n        transition: &#39;style&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of the element.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When it&#39;s highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state, available when <code class=\"codespan\">focus</code> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state, available when <a href=\"#series-custom.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}}}},"return_line":{"type":["Object"],"description":"<p>Line element.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#series-custom.renderItem.return_image\">image</a>,\n<a href=\"#series-custom.renderItem.return_text\">text</a>,\n<a href=\"#series-custom.renderItem.return_circle\">circle</a>,\n<a href=\"#series-custom.renderItem.return_sector\">sector</a>,\n<a href=\"#series-custom.renderItem.return_ring\">ring</a>,\n<a href=\"#series-custom.renderItem.return_polygon\">polygon</a>,\n<a href=\"#series-custom.renderItem.return_polyline\">polyline</a>,\n<a href=\"#series-custom.renderItem.return_rect\">rect</a>,\n<a href=\"#series-custom.renderItem.return_line\">line</a>,\n<a href=\"#series-custom.renderItem.return_bezierCurve\">bezierCurve</a>,\n<a href=\"#series-custom.renderItem.return_arc\">arc</a>,\n<a href=\"#series-custom.renderItem.return_group\">group</a>,</p>\n","default":"line"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_line.x\">x</a> and <a href=\"#series-custom.renderItem.return_line.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_line.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_line.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_line.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_line.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_line.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_line.x\">x</a> and <a href=\"#series-custom.renderItem.return_line.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_line.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_line.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_line.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_line.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_line.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_line.x\">x</a> and <a href=\"#series-custom.renderItem.return_line.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_line.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_line.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_line.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_line.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_line.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_line.x\">x</a> and <a href=\"#series-custom.renderItem.return_line.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_line.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_line.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_line.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_line.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_line.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_line.x\">x</a> and <a href=\"#series-custom.renderItem.return_line.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_line.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_line.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_line.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_line.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_line.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_line.x\">x</a> and <a href=\"#series-custom.renderItem.return_line.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_line.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_line.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_line.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_line.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_line.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_line.x\">x</a> and <a href=\"#series-custom.renderItem.return_line.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_line.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_line.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_line.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_line.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_line.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.</p>\n<p>The properties can only be:</p>\n<ul>\n<li>Transform related properties: <a href=\"#series-custom.renderItem.return_line.x\"><code class=\"codespan\">&#39;x&#39;</code></a>, <a href=\"#series-custom.renderItem.return_line.y\"><code class=\"codespan\">&#39;y&#39;</code></a>, <a href=\"#series-custom.renderItem.return_line.scaleX\"><code class=\"codespan\">&#39;scaleX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_line.scaleY\"><code class=\"codespan\">&#39;scaleY&#39;</code></a>, <a href=\"#series-custom.renderItem.return_line.rotation\"><code class=\"codespan\">&#39;rotation&#39;</code></a>, <a href=\"#series-custom.renderItem.return_line.originX\"><code class=\"codespan\">&#39;originX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_line.originY\"><code class=\"codespan\">&#39;originY&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      var coord = api.coord([api.value(0), api.value[1]);\n      return {\n          type: &#39;rect&#39;,\n          x: coord[0],\n          y: coord[1],\n          shape: {\n              x: 0,\n              y: 0,\n              width: api.value(2),\n              height: 100\n          },\n          transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;]\n      }\n  }\n</code></pre>\n</li>\n<li>Shortcut to transition all of the properties in <a href=\"#series-custom.renderItem.return_line.shape\"><code class=\"codespan\">&#39;shape&#39;</code></a>, <a href=\"#series-custom.renderItem.return_line.style\">&#39;<code class=\"codespan\">style&#39;</code></a>, <a href=\"#series-custom.renderItem.return_line.extra\"><code class=\"codespan\">&#39;extra&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3)\n          },\n          // Indicate that all props in `shape` will\n          // have transition animation.\n          transition: &#39;shape&#39;,\n      };\n  }\n</code></pre>\n  It is equivalent to:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3),\n              // This usage can only enable part of the\n              // properties transition.\n              transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;, &#39;height&#39;]\n          }\n      };\n  }\n</code></pre>\n</li>\n</ul>\n<p>By default, <a href=\"#series-custom.renderItem.return_line.x\"><code class=\"codespan\">&#39;x&#39;</code></a> and <a href=\"#series-custom.renderItem.return_line.y\"><code class=\"codespan\">&#39;y&#39;</code></a> are transitioned. If you want to disable the default transition, just set it as:</p>\n<pre><code class=\"lang-js\">transition: [] // Am empty array.\n</code></pre>\n<p>See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/custom-transition-simple&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> please.</p>\n","default":"['x', 'y']"},"morph":{"type":["boolean"],"description":"<p>Whether to enable morphing animation.</p>\n<p><strong>When morphing animation happen?</strong></p>\n<p>If <code class=\"codespan\">morph</code> is set as <code class=\"codespan\">true</code>, the morphing animation will happen according to the following rule:</p>\n<p>Each time the render process happen, custom series will diff the old data and the new data. If a set of old data items (say, &quot;old set&quot;) are value-equal to a set of new data items (say, &quot;new set&quot;) in name or the specified dimensions (see parameter <a href=\"api.html#echartsInstance.setOption\" target=\"_blank\">transition</a> in <code class=\"codespan\">setOption</code>), we found a pair of sets as transition candidates.</p>\n<p>Three type of transition animation can be performed between the two sets:</p>\n<ul>\n<li>one-to-one: if both the two sets has only one data item.</li>\n<li>one-to-many(separate): if the &quot;old set&quot; has only one data item, and the &quot;new set&quot; has more than one data items.</li>\n<li>many-to-one(combine): if the &quot;old set&quot; has more than one data items, and the &quot;new set&quot; has only one data item.</li>\n</ul>\n<p>Note: we do not support transition animation for the case many-to-many.</p>\n<p>Then custom series find graphic elements that has <code class=\"codespan\">morph: true</code> declared in these two sets, and map them for one to one morphing or combining or separating.</p>\n<p>See examples: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-one-to-one-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-one-to-one-morph</a> and\n<a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-combine-separate-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-combine-separate-morph</a>.</p>\n","default":false},"z2":{"type":["number"],"description":"<p>Define the overlap relationship between graphic elements.</p>\n","default":"undefined"},"name":{"type":["string"],"description":"<p>See <a href=\"#series-custom.renderItem.return_line.diffChildrenByName\">diffChildrenByName</a>.</p>\n","default":"undefined"},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"x1":{"type":["number"],"description":"<p>x value of the start point.</p>\n","default":0},"y1":{"type":["number"],"description":"<p>y value of the start point.</p>\n","default":0},"x2":{"type":["number"],"description":"<p>x value of the end point.</p>\n","default":0},"y2":{"type":["number"],"description":"<p>y value of the end point.</p>\n","default":0},"percent":{"type":["number"],"description":"<p>Specify the percentage of drawing, useful in animation.</p>\n<p>Value range: [0, 1].</p>\n","default":1},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">shape</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `shape` will\n        // have transition animation.\n        transition: &#39;shape&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":null},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":"\"#000\""},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":5},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">style</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `style` will\n        // have transition animation.\n        transition: &#39;style&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of the element.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When it&#39;s highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state, available when <code class=\"codespan\">focus</code> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state, available when <a href=\"#series-custom.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}}}},"return_bezierCurve":{"type":["Object"],"description":"<p>Quadratic bezier curve or cubic bezier curve.</p>\n","properties":{"type":{"type":["string"],"description":"<p>Must be specified when define a graphic element at the first time.</p>\n<p>Optional values:</p>\n<p><a href=\"#series-custom.renderItem.return_image\">image</a>,\n<a href=\"#series-custom.renderItem.return_text\">text</a>,\n<a href=\"#series-custom.renderItem.return_circle\">circle</a>,\n<a href=\"#series-custom.renderItem.return_sector\">sector</a>,\n<a href=\"#series-custom.renderItem.return_ring\">ring</a>,\n<a href=\"#series-custom.renderItem.return_polygon\">polygon</a>,\n<a href=\"#series-custom.renderItem.return_polyline\">polyline</a>,\n<a href=\"#series-custom.renderItem.return_rect\">rect</a>,\n<a href=\"#series-custom.renderItem.return_line\">line</a>,\n<a href=\"#series-custom.renderItem.return_bezierCurve\">bezierCurve</a>,\n<a href=\"#series-custom.renderItem.return_arc\">arc</a>,\n<a href=\"#series-custom.renderItem.return_group\">group</a>,</p>\n","default":"bezierCurve"},"id":{"type":["string"],"description":"<p>id is used to specifying element when willing to update it.\nid can be ignored if you do not need it.</p>\n","default":"undefined"},"x":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_bezierCurve.x\">x</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_bezierCurve.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_bezierCurve.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_bezierCurve.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"y":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_bezierCurve.x\">x</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_bezierCurve.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_bezierCurve.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_bezierCurve.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"rotation":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_bezierCurve.x\">x</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_bezierCurve.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_bezierCurve.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_bezierCurve.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"scaleX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_bezierCurve.x\">x</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_bezierCurve.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_bezierCurve.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_bezierCurve.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"scaleY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_bezierCurve.x\">x</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_bezierCurve.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_bezierCurve.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_bezierCurve.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":1},"originX":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_bezierCurve.x\">x</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_bezierCurve.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_bezierCurve.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_bezierCurve.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"originY":{"type":["number"],"description":"<p><code class=\"codespan\">2D transform</code> can be applied to graphic elements, including:</p>\n<ul>\n<li>Translate by <a href=\"#series-custom.renderItem.return_bezierCurve.x\">x</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.y\">y</a>: <code class=\"codespan\">0</code> by default. Positive value means translate towards right or bottom.</li>\n<li>Rotate by <a href=\"#series-custom.renderItem.return_bezierCurve.rotation\">rotation</a>: in radian, <code class=\"codespan\">0</code> by default. Positive when anticlockwise.</li>\n<li>Scale by <a href=\"#series-custom.renderItem.return_bezierCurve.scaleX\">scaleX</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.scaleY\">scaleY</a>: <code class=\"codespan\">1</code> by default. The value means the ratio of scale.</li>\n</ul>\n<p><a href=\"#series-custom.renderItem.return_bezierCurve.originX\">originX</a> and <a href=\"#series-custom.renderItem.return_bezierCurve.originY\">originY</a> specifies the origin point of rotation and scaling, <code class=\"codespan\">0</code>, <code class=\"codespan\">0</code> by default.</p>\n<p>Notice:</p>\n<ul>\n<li>The coordinates specified in the transform attribute above are relative to the <code class=\"codespan\">[0, 0]</code> of the parent element (that is, <a href=\"#series-custom.renderItem.return_group\">group</a> or the root canvas). Thus we are able to <a href=\"#series-custom.renderItem.return_group\">group</a> multiple elements, and <a href=\"#series-custom.renderItem.return_group\">groups</a> can be nested.</li>\n<li>The order that the transform attributes are applied to a single graphic element is: firstly, rotate (by <code class=\"codespan\">rotation</code>); then, scale (by <code class=\"codespan\">scaleX</code>, <code class=\"codespan\">scaleY</code>); finally, translate (by <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>).</li>\n</ul>\n","default":0},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.</p>\n<p>The properties can only be:</p>\n<ul>\n<li>Transform related properties: <a href=\"#series-custom.renderItem.return_bezierCurve.x\"><code class=\"codespan\">&#39;x&#39;</code></a>, <a href=\"#series-custom.renderItem.return_bezierCurve.y\"><code class=\"codespan\">&#39;y&#39;</code></a>, <a href=\"#series-custom.renderItem.return_bezierCurve.scaleX\"><code class=\"codespan\">&#39;scaleX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_bezierCurve.scaleY\"><code class=\"codespan\">&#39;scaleY&#39;</code></a>, <a href=\"#series-custom.renderItem.return_bezierCurve.rotation\"><code class=\"codespan\">&#39;rotation&#39;</code></a>, <a href=\"#series-custom.renderItem.return_bezierCurve.originX\"><code class=\"codespan\">&#39;originX&#39;</code></a>, <a href=\"#series-custom.renderItem.return_bezierCurve.originY\"><code class=\"codespan\">&#39;originY&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      var coord = api.coord([api.value(0), api.value[1]);\n      return {\n          type: &#39;rect&#39;,\n          x: coord[0],\n          y: coord[1],\n          shape: {\n              x: 0,\n              y: 0,\n              width: api.value(2),\n              height: 100\n          },\n          transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;]\n      }\n  }\n</code></pre>\n</li>\n<li>Shortcut to transition all of the properties in <a href=\"#series-custom.renderItem.return_bezierCurve.shape\"><code class=\"codespan\">&#39;shape&#39;</code></a>, <a href=\"#series-custom.renderItem.return_bezierCurve.style\">&#39;<code class=\"codespan\">style&#39;</code></a>, <a href=\"#series-custom.renderItem.return_bezierCurve.extra\"><code class=\"codespan\">&#39;extra&#39;</code></a>. For example:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3)\n          },\n          // Indicate that all props in `shape` will\n          // have transition animation.\n          transition: &#39;shape&#39;,\n      };\n  }\n</code></pre>\n  It is equivalent to:<pre><code class=\"lang-js\">  renderItem: function (params, api) {\n      return {\n          type: &#39;rect&#39;,\n          shape: {\n              x: api.value(0),\n              y: api.value(1),\n              width: api.value(2),\n              height: api.value(3),\n              // This usage can only enable part of the\n              // properties transition.\n              transition: [&#39;x&#39;, &#39;y&#39;, &#39;width&#39;, &#39;height&#39;]\n          }\n      };\n  }\n</code></pre>\n</li>\n</ul>\n<p>By default, <a href=\"#series-custom.renderItem.return_bezierCurve.x\"><code class=\"codespan\">&#39;x&#39;</code></a> and <a href=\"#series-custom.renderItem.return_bezierCurve.y\"><code class=\"codespan\">&#39;y&#39;</code></a> are transitioned. If you want to disable the default transition, just set it as:</p>\n<pre><code class=\"lang-js\">transition: [] // Am empty array.\n</code></pre>\n<p>See this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=doc-example/custom-transition-simple&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> please.</p>\n","default":"['x', 'y']"},"morph":{"type":["boolean"],"description":"<p>Whether to enable morphing animation.</p>\n<p><strong>When morphing animation happen?</strong></p>\n<p>If <code class=\"codespan\">morph</code> is set as <code class=\"codespan\">true</code>, the morphing animation will happen according to the following rule:</p>\n<p>Each time the render process happen, custom series will diff the old data and the new data. If a set of old data items (say, &quot;old set&quot;) are value-equal to a set of new data items (say, &quot;new set&quot;) in name or the specified dimensions (see parameter <a href=\"api.html#echartsInstance.setOption\" target=\"_blank\">transition</a> in <code class=\"codespan\">setOption</code>), we found a pair of sets as transition candidates.</p>\n<p>Three type of transition animation can be performed between the two sets:</p>\n<ul>\n<li>one-to-one: if both the two sets has only one data item.</li>\n<li>one-to-many(separate): if the &quot;old set&quot; has only one data item, and the &quot;new set&quot; has more than one data items.</li>\n<li>many-to-one(combine): if the &quot;old set&quot; has more than one data items, and the &quot;new set&quot; has only one data item.</li>\n</ul>\n<p>Note: we do not support transition animation for the case many-to-many.</p>\n<p>Then custom series find graphic elements that has <code class=\"codespan\">morph: true</code> declared in these two sets, and map them for one to one morphing or combining or separating.</p>\n<p>See examples: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-one-to-one-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-one-to-one-morph</a> and\n<a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=custom-combine-separate-morph&amp;edit=1&amp;reset=1\" target=\"_blank\">custom-combine-separate-morph</a>.</p>\n","default":false},"z2":{"type":["number"],"description":"<p>Define the overlap relationship between graphic elements.</p>\n","default":"undefined"},"name":{"type":["string"],"description":"<p>See <a href=\"#series-custom.renderItem.return_bezierCurve.diffChildrenByName\">diffChildrenByName</a>.</p>\n","default":"undefined"},"info":{"type":["*"],"description":"<p>User defined data, can be visited in event listeners.</p>\n<pre><code class=\"lang-js\">chart.on(&#39;click&#39;, function (params) {\n    console.log(params.info);\n});\n</code></pre>\n"},"silent":{"type":["boolean"],"description":"<p>Whether response to mouse events / touch events.</p>\n","default":false},"invisible":{"type":["boolean"],"description":"<p>Whether the element is visible.</p>\n","default":false},"ignore":{"type":["boolean"],"description":"<p>Whether the element is totally ignored (neither render nor listen events).</p>\n","default":false},"shape":{"type":["Object"],"description":"","properties":{"x1":{"type":["number"],"description":"<p>x value of the start point.</p>\n","default":0},"y1":{"type":["number"],"description":"<p>y value of the start point.</p>\n","default":0},"x2":{"type":["number"],"description":"<p>x value of the end point.</p>\n","default":0},"y2":{"type":["number"],"description":"<p>y value of the end point.</p>\n","default":0},"cpx1":{"type":["number"],"description":"<p>x of control point.</p>\n","default":0},"cpy1":{"type":["number"],"description":"<p>y of control point.</p>\n","default":0},"cpx2":{"type":["number"],"description":"<p>x of the second control point. If specified, cubic bezier is used.</p>\n<p>If both <code class=\"codespan\">cpx2</code> and <code class=\"codespan\">cpy2</code> are not set, quatratic bezier is used.</p>\n","default":null},"cpy2":{"type":["number"],"description":"<p>y of the second control point. If specified, cubic bezier is used.</p>\n<p>If both <code class=\"codespan\">cpx2</code> and <code class=\"codespan\">cpy2</code> are not set, quatratic bezier is used.</p>\n","default":null},"percent":{"type":["number"],"description":"<p>Specify the percentage of drawing, useful in animation.</p>\n<p>Value range: [0, 1].</p>\n","default":1},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">shape</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        shape: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `shape` will\n        // have transition animation.\n        transition: &#39;shape&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"style":{"type":["Object"],"description":"<p>More attributes in <code class=\"codespan\">style</code> (for example, <a href=\"tutorial.html#Rich%20Text\" target=\"_blank\">rich text</a>), see the <code class=\"codespan\">style</code> related attributes in <a href=\"https://ecomfe.github.io/zrender-doc/public/api.html#zrenderdisplayable\" target=\"_blank\">zrender/graphic/Displayable</a>.</p>\n<p>Notice, the attribute names of the <code class=\"codespan\">style</code> of graphic elements is derived from <code class=\"codespan\">zrender</code>, which may be different from the attribute names in <code class=\"codespan\">echarts label</code>, <code class=\"codespan\">echarts itemStyle</code>, etc., although they have the same meaning. For example:</p>\n<ul>\n<li><a href=\"#series-scatter.label.color\">itemStyle.color</a> =&gt; <code class=\"codespan\">style.fill</code></li>\n<li><a href=\"#series-scatter.label.color\">itemStyle.borderColor</a> =&gt; <code class=\"codespan\">style.stroke</code></li>\n<li><a href=\"#series-scatter.label.color\">label.color</a> =&gt; <code class=\"codespan\">style.textFill</code></li>\n<li><a href=\"#series-scatter.label.textBorderColor\">label.textBorderColor</a> =&gt; <code class=\"codespan\">style.textStroke</code></li>\n<li>...</li>\n</ul>\n","properties":{"fill":{"type":["string"],"description":"<p>Color filled in this element.</p>\n","default":"'#000'"},"stroke":{"type":["string"],"description":"<p>Color of stroke.</p>\n","default":null},"lineWidth":{"type":["number"],"description":"<p>Width of stroke.</p>\n","default":0},"shadowBlur":{"type":["number"],"description":"<p>Width of shadow.</p>\n","default":"undefined"},"shadowOffsetX":{"type":["number"],"description":"<p>X offset of shadow.</p>\n","default":"undefined"},"shadowOffsetY":{"type":["number"],"description":"<p>Y offset of shadow.</p>\n","default":"undefined"},"shadowColor":{"type":["number"],"description":"<p>color of shadow.</p>\n","default":"undefined"},"transition":{"type":["string","Array"],"description":"<p>Can be a single property name or an array of property names.\nEnable transition animation when the specified properties changed.\nCan only specify properties that are under this <code class=\"codespan\">style</code>.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n            // This two props will perform transition animation.\n            transition: [&#39;mmm&#39;, &#39;ppp&#39;]\n        }\n    };\n}\n</code></pre>\n<p>We can also specify all of the properties like this:</p>\n<pre><code class=\"lang-js\">renderItem: function (params, api) {\n    return {\n        type: &#39;xxx&#39;,\n        style: {\n            mmm: ...,\n            nnn: ...,\n            ppp: ...,\n            qqq: ...,\n        },\n        // Indicate that all props in `style` will\n        // have transition animation.\n        transition: &#39;style&#39;,\n    };\n}\n</code></pre>\n","default":"undefined"}}},"emphasis":{"type":["Object"],"description":"<p>Emphasis state of the element.</p>\n","properties":{"focus":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>When it&#39;s highlighted, whether to fade out of other data to focus the highlighted. The following configurations are supported:</p>\n<ul>\n<li><code class=\"codespan\">&#39;none&#39;</code> Do not fade out other data, it&#39;s by default.</li>\n<li><code class=\"codespan\">&#39;self&#39;</code> Only focus (not fade out) the element of the currently highlighted data.</li>\n<li><code class=\"codespan\">&#39;series&#39;</code> Focus on all elements of the series which the currently highlighted data belongs to.</li>\n</ul>\n","default":"'none'"},"blurScope":{"type":["string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>The range of fade out when <code class=\"codespan\">focus</code> is enabled. Support the following configurations</p>\n<ul>\n<li><code class=\"codespan\">&#39;coordinateSystem&#39;</code></li>\n<li><code class=\"codespan\">&#39;series&#39;</code></li>\n<li><code class=\"codespan\">&#39;global&#39;</code></li>\n</ul>\n","default":"'coordinateSystem'"},"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"blur":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Blur state, available when <code class=\"codespan\">focus</code> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}},"select":{"type":["Object"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Select state, available when <a href=\"#series-custom.selectedMode\">selectedMode</a> is set.</p>\n","properties":{"style":{"type":["Object"],"description":"<p>Same to <a href=\"#series-custom.renderItem.return_polygon.style\">style</a>.</p>\n"}}}}}}},"itemStyle":{"type":["Object"],"description":"<p>Graphic style of , <code class=\"codespan\">emphasis</code> is the style when it is highlighted, like being hovered by mouse, or highlighted via legend connect.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> color.  Color is taken from <a href=\"#color\">option.color Palette</a> by default. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"labelLine":{"type":["Object"],"description":"<p>Configuration of label guide line.</p>\n","properties":{"show":{"type":["boolean"],"description":"\n\n<p>Whether to show the label guide line.</p>\n","uiControl":{"type":"boolean"}},"showAbove":{"type":["boolean"],"description":"<p>Whether to show the label guide line above the corresponding element.</p>\n"},"length2":{"type":["number"],"description":"\n\n<p>The length of the second segment of guide line.</p>\n","uiControl":{"type":"number","default":"15","min":"0","step":"1"}},"smooth":{"type":["boolean","number"],"description":"\n\n<p>Whether to smooth the guide line. It defaults to be <code class=\"codespan\">false</code> and can be set as <code class=\"codespan\">true</code> or the values from 0 to 1 which indicating the smoothness.</p>\n","uiControl":{"type":"boolean"},"default":false},"minTurnAngle":{"type":["number"],"description":"<p>Minimum turn angle between two segments of guide line to prevent unaesthetic display when angle is too small.</p>\n<p>Can be 0 - 180 degree.</p>\n","default":null},"lineStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p>Line color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":"\"#000\""},"width":{"type":["number"],"description":"\n\n<p> line width.</p>\n","uiControl":{"type":"number","value":"1","min":"0","step":"0.5"},"default":0},"type":{"type":["string"],"description":"\n\n<p> line type.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;solid&#39;</code></li>\n<li><code class=\"codespan\">&#39;dashed&#39;</code></li>\n<li><code class=\"codespan\">&#39;dotted&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"solid"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"labelLayout":{"type":["Object","Function"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n<p>Unified layout configuration of labels.</p>\n<p>It provide a chance to adjust the labels&#39; <code class=\"codespan\">(x, y)</code> position, alignment based on the original layout each series provides.</p>\n<p>This option can be a callback with following parameters.</p>\n<pre><code class=\"lang-js\">// corresponding index of data\ndataIndex: number\n// corresponding type of data. Only available in graph, in which it can be &#39;node&#39; or &#39;edge&#39;\ndataType?: string\n// corresponding index of series\nseriesIndex: number\n// Displayed text of label.\ntext: string\n// Bounding rectangle of label.\nlabelRect: {x: number, y: number, width: number, height: number}\n// Horizontal alignment of label.\nalign: &#39;left&#39; | &#39;center&#39; | &#39;right&#39;\n// Vertical alignment of label.\nverticalAlign: &#39;top&#39; | &#39;middle&#39; | &#39;bottom&#39;\n// Bounding rectangle of the element corresponding to.\nrect: {x: number, y: number, width: number, height: number}\n// Default points array of labelLine. Currently only provided in pie and funnel series.\n// It&#39;s null in other series.\nlabelLinePoints?: number[][]\n</code></pre>\n<p><strong>Example:</strong></p>\n<p>Align the labels on the right. Left 10px margin to the edge.</p>\n<pre><code class=\"lang-js\">labelLayout(params) {\n    return {\n        x: params.rect.x + 10,\n        y: params.rect.y + params.rect.height / 2,\n        verticalAlign: &#39;middle&#39;,\n        align: &#39;left&#39;\n    }\n}\n</code></pre>\n<p>Set the text size based on the size of element bounding rectangle.</p>\n<pre><code class=\"lang-js\">\nlabelLayout(params) {\n    return {\n        fontSize: Math.max(params.rect.width / 10, 5)\n    };\n}\n</code></pre>\n","properties":{"hideOverlap":{"type":["boolean"],"description":"<p>If hide the overlapped labels.</p>\n<p>The following example shows how to hide the overlapped labels in graph automatically when zooming.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=graph-label-overlap&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"moveOverlap":{"type":["string"],"description":"<p>If move the overlapped labels to avoid overlapping.</p>\n<p>Currently supported configurations:</p>\n<ul>\n<li><code class=\"codespan\">&#39;shiftX&#39;</code> Place the labels on horizontal direction sequencely, used when aligned horizontally.</li>\n<li><code class=\"codespan\">&#39;shiftY&#39;</code> Place the labels on vertial direction sequencely, used when aligned vertically.</li>\n</ul>\n<p>The following example shows how to use <code class=\"codespan\">moverOverlap: &#39;shiftY&#39;</code> to place the labels aligned vertically.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=scatter-label-align-right&edit=1&reset=1\" width=\"600\" height=\"400\"></iframe>\n\n"},"x":{"type":["number","string"],"description":"<p>The x position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"y":{"type":["number","string"],"description":"<p>The y position of the label. Support absolute pixel values ​​or relative values ​​such as <code class=\"codespan\">&#39;20%&#39;</code>.</p>\n"},"dx":{"type":["number"],"description":"<p>The pixel offset of the label in the x direction. Can be used with <code class=\"codespan\">x</code>.</p>\n"},"dy":{"type":["number"],"description":"<p>The pixel offset of the label in the y direction. Can be used with <code class=\"codespan\">y</code></p>\n"},"rotate":{"type":["number"],"description":"<p>Label rotation angle.</p>\n"},"width":{"type":["number"],"description":"<p>The width of displayed label. Can be used with <code class=\"codespan\">overflow</code> to constraint the label in a fixed width</p>\n"},"height":{"type":["number"],"description":"<p>The height of displayed label. Can be used with <code class=\"codespan\">lineOverflow</code> to constraint the label in a fixed height.</p>\n"},"align":{"type":["string"],"description":"<p>The horizontal alignment of the label. Can be <code class=\"codespan\">&#39;left&#39;</code>, <code class=\"codespan\">&#39;center&#39;</code>, <code class=\"codespan\">&#39;right&#39;</code>.</p>\n"},"verticalAlign":{"type":["string"],"description":"<p>The vertical alignment of the label. Can be <code class=\"codespan\">&#39;top&#39;</code>, <code class=\"codespan\">&#39;middle&#39;</code>, <code class=\"codespan\">&#39;bottom&#39;</code>.</p>\n"},"fontSize":{"type":["number"],"description":"<p>The text size of the label.</p>\n"},"draggable":{"type":["boolean"],"description":"<p>Whether to allow the user to adjust the position by dragging.</p>\n"},"labelLinePoints":{"type":["Array"],"description":"<p>The array of the three points of the label guide line. The format is:</p>\n<pre><code class=\"lang-js\">[[x, y], [x, y], [x, y]]\n</code></pre>\n<p>It is often used in pie charts to fine-tune the guide line that has been calculated. Usually not recommended to set it in other situations.</p>\n"}}},"selectedMode":{"type":["boolean","string"],"description":"<blockquote>\n<p>Since <code class=\"codespan\">v5.0.0</code></p>\n</blockquote>\n\n\n<p>Selected mode.  It is enabled by default, and you may set it to be <code class=\"codespan\">false</code> to disabled it.</p>\n<p>Besides, it can be set to <code class=\"codespan\">&#39;single&#39;</code> or <code class=\"codespan\">&#39;multiple&#39;</code>, for single selection and multiple selections.</p>\n","uiControl":{"type":"enum","options":"false,true,single,multiple"},"default":false},"dimensions":{"type":["Array"],"description":"<p><code class=\"codespan\">dimensions</code> can be used to define dimension info for <code class=\"codespan\">series.data</code> or <code class=\"codespan\">dataset.source</code>.</p>\n<p>Notice: if <a href=\"#dataset\">dataset</a> is used, we can definite dimensions in <a href=\"#dataset.dimensions\">dataset.dimensions</a>, or provide dimension names in the first column/row of <a href=\"#dataset.source\">dataset.source</a>, and not need to specify <code class=\"codespan\">dimensions</code> here. But if <code class=\"codespan\">dimensions</code> is specified here, it will be used despite the dimension definitions in dataset.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // &#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        // Specify name for each dimesions, which will be displayed in tooltip.\n        dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [\n        null,                // If you do not intent to defined this dimension, use null is fine.\n        {type: &#39;ordinal&#39;},   // Specify type of this dimension.\n                             // &#39;ordinal&#39; is always used in string.\n                             // If type is not specified, echarts will guess type by data.\n        {name: &#39;good&#39;, type: &#39;number&#39;},\n        &#39;bad&#39;                // Equals to {name: &#39;bad&#39;}.\n    ]\n}\n</code></pre>\n<p>Each data item of <code class=\"codespan\">dimensions</code> can be:</p>\n<ul>\n<li><code class=\"codespan\">string</code>, for example, <code class=\"codespan\">&#39;someName&#39;</code>, which equals to <code class=\"codespan\">{name: &#39;someName&#39;}</code>.</li>\n<li><code class=\"codespan\">Object</code>, where the attributes can be:<ul>\n<li>name: <code class=\"codespan\">string</code>.</li>\n<li>type: <code class=\"codespan\">string</code>, supports:<ul>\n<li><code class=\"codespan\">number</code></li>\n<li><code class=\"codespan\">float</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array\" target=\"_blank\">Float64Array</a></li>\n<li><code class=\"codespan\">int</code>, that is, <a href=\"https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array\" target=\"_blank\">Int32Array</a></li>\n<li><code class=\"codespan\">ordinal</code>, discrete value, which represents string generally.</li>\n<li><code class=\"codespan\">time</code>, time value, see <a href=\"#series.data\">data</a> to check the format of time value.</li>\n</ul>\n</li>\n<li>displayName: <code class=\"codespan\">string</code>, generally used in tooltip for dimension display. If not specified, use <code class=\"codespan\">name</code> by default.</li>\n</ul>\n</li>\n</ul>\n<p>When <code class=\"codespan\">dimensions</code> is specified, the default <code class=\"codespan\">tooltip</code> will be displayed vertically, which is better to show diemsion names. Otherwise, <code class=\"codespan\">tooltip</code> will displayed only value horizontally.</p>\n"},"encode":{"type":["Object"],"description":"<p>Define what is encoded to for each dimension of <code class=\"codespan\">data</code>. For example:</p>\n<pre><code class=\"lang-js\">option = {\n    dataset: {\n        source: [\n            // Each column is called a dimension.\n            // There are five dimensions: 0, 1, 2, 3, 4.\n            [12, 44, 55, 66, 2],\n            [23, 6, 16, 23, 1],\n            ...\n        ]\n    },\n    series: {\n        type: &#39;xxx&#39;,\n        encode: {\n            x: [3, 1, 5],      // Dimension 3, 1, 5 is mapped to x axis.\n            y: 2,              // Dimension 2 is mapped to y axis.\n            tooltip: [3, 2, 4] // Dimension 3, 2, 4 will be displayed in tooltip.\n        }\n    }\n}\n</code></pre>\n<p>When <a href=\"#series.dimensions\">dimensions</a> is used to defined name for a certain dimension, <code class=\"codespan\">encode</code> can refer the name directly. For example:</p>\n<pre><code class=\"lang-js\">series: {\n    type: &#39;xxx&#39;,\n    dimensions: [&#39;date&#39;, &#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;],\n    encode: {\n        x: &#39;date&#39;,\n        y: [&#39;open&#39;, &#39;close&#39;, &#39;highest&#39;, &#39;lowest&#39;]\n    }\n}\n</code></pre>\n<p>The basic structure of <a href=\"option.html#series.encode\" target=\"_blank\">encode</a> is illustrated as follows, where the left part of colon is the name of axis like <code class=\"codespan\">&#39;x&#39;</code>, <code class=\"codespan\">&#39;y&#39;</code>, <code class=\"codespan\">&#39;radius&#39;</code>, <code class=\"codespan\">&#39;angle&#39;</code> or some special reserved names like &quot;tooltip&quot;, &quot;itemName&quot; etc., and the right part of the colon is the dimension names or dimension indices (based on 0). One or more dimensions can be specified. Usually not all of mappings need to be specified, only specify needed ones.</p>\n<p>The properties available in <code class=\"codespan\">encode</code> listed as follows:</p>\n<pre><code class=\"lang-js\">// In any of the series and coordinate systems,\n// these properties are available:\nencode: {\n    // Display dimension &quot;product&quot; and &quot;score&quot; in the tooltip.\n    tooltip: [&#39;product&#39;, &#39;score&#39;]\n    // Set the series name as the concat of the names of dimensions[1] and dimensions[3].\n    // (sometimes the dimension names are too long to type in series.name manually).\n    seriesName: [1, 3],\n    // Using dimensions[2] as the id of each data item. This is useful when dynamically\n    // update data by `chart.setOption()`, where the new and old data item can be\n    // corresponded by id, by which the appropriate animation can be performed when updating.\n    itemId: 2,\n    // Using dimensions[3] as the name of each data item. This is useful in charts like\n    // &#39;pie&#39;, &#39;funnel&#39;, where data item name can be displayed in legend.\n    itemName: 3\n}\n\n// These properties only work in cartesian(grid) coordinate system:\nencode: {\n    // Map dimensions[1], dimensions[5] and dimension &quot;score&quot; to the X axis.\n    x: [1, 5, &#39;score&#39;],\n    // Map dimensions[0] to the Y axis.\n    y: 0\n}\n\n// These properties only work in polar coordinate system:\nencode: {\n    radius: 3,\n    angle: 2,\n    ...\n}\n\n// These properties only work in geo coordinate system:\nencode: {\n    lng: 3,\n    lat: 2\n}\n\n// For some type of series that are not in any coordinate system,\n// like &#39;pie&#39;, &#39;funnel&#39; etc.:\nencode: {\n    value: 3\n}\n</code></pre>\n<p>This is an <a href=\"https://echarts.apache.org/next/examples/en/view.html?c=dataset-encode1&amp;edit=1&amp;reset=1\" target=\"_blank\">example</a> for <code class=\"codespan\">encode</code>.</p>\n<p>Specially, in [custom series(~series-custom), some property in <code class=\"codespan\">encode</code>, corresponding to axis, can be set as null to make the series not controlled by the axis, that is, the series data will not be count in the extent of the axis, and the <a href=\"#dataZoom\">dataZoom</a> on the axis will not filter the series.</p>\n<pre><code class=\"lang-js\">var option = {\n    xAxis: {},\n    yAxis: {},\n    dataZoom: [{\n        xAxisIndex: 0\n    }, {\n        yAxisIndex: 0\n    }],\n    series: {\n        type: &#39;custom&#39;,\n        renderItem: function (params, api) {\n            return {\n                type: &#39;circle&#39;,\n                shape: {\n                    cx: 100, // x position is always 100\n                    cy: api.coord([0, api.value(0)])[1],\n                    r: 30\n                },\n                style: {\n                    fill: &#39;blue&#39;\n                }\n            };\n        },\n        encode: {\n            // Then the series will not be controlled\n            // by x axis and corresponding dataZoom.\n            x: -1,\n            y: 1\n        },\n        data: [ ... ]\n    }\n};\n</code></pre>\n"},"seriesLayoutBy":{"type":["string"],"description":"<p>When <a href=\"#dataset\">dataset</a> is used, <code class=\"codespan\">seriesLayoutBy</code> specifies whether the column or the row of <code class=\"codespan\">dataset</code> is mapped to the series, namely, the series is &quot;layout&quot; on columns or rows. Optional values:</p>\n<ul>\n<li>&#39;column&#39;: by default, the columns of <code class=\"codespan\">dataset</code> are mapped the series. In this case, each column represents a dimension.</li>\n<li>&#39;row&#39;：the rows of <code class=\"codespan\">dataset</code> are mapped to the series. In this case, each row represents a dimension.</li>\n</ul>\n<p>Check this <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=dataset-series-layout-by\" target=\"_blank\">example</a>.</p>\n","default":"'column'"},"datasetIndex":{"type":["number"],"description":"<p>If <a href=\"#series.data\">series.data</a> is not specified, and <a href=\"#dataset\">dataset</a> exists, the series will use <code class=\"codespan\">dataset</code>. <code class=\"codespan\">datasetIndex</code> specifies which dataset will be used.</p>\n","default":0},"data":{"type":["Array"],"description":"<p>Data array of series, which can be in the following forms:</p>\n<p>Notice, if no <code class=\"codespan\">data</code> specified in series, and there is <a href=\"#dataset\">dataset</a> in option, series will use the first <a href=\"#dataset\">dataset</a> as its datasource. If <code class=\"codespan\">data</code> has been specified, <a href=\"#dataset\">dataset</a> will not used.</p>\n<p><code class=\"codespan\">series.datasetIndex</code> can be used to specify other <a href=\"#dataset\">dataset</a>.</p>\n<p>Basically, data is represented by a two-dimension array, like the example below, where each column is named as a &quot;dimension&quot;.</p>\n<pre><code class=\"lang-js\">series: [{\n    data: [\n        // dimX   dimY   other dimensions ...\n        [  3.4,    4.5,   15,   43],\n        [  4.2,    2.3,   20,   91],\n        [  10.8,   9.5,   30,   18],\n        [  7.2,    8.8,   18,   57]\n    ]\n}]\n</code></pre>\n<ul>\n<li>In <a href=\"#grid\">cartesian (grid)</a>, &quot;dimX&quot; and &quot;dimY&quot; correspond to <a href=\"#xAxis\">xAxis</a> and <a href=\"#yAxis\">yAxis</a> respectively.</li>\n<li>In <a href=\"#polar\">polar</a> &quot;dimX&quot; and &quot;dimY&quot; correspond to <a href=\"#radiusAxis\">radiusAxis</a> 和 <a href=\"#anbleAxis\">angleAxis</a> respectively.</li>\n<li>Other dimensions are optional, which can be used in other places. For example:<ul>\n<li><a href=\"#visualMap\">visualMap</a> can map one or more dimensions to visual (color, symbol size ...).</li>\n<li><a href=\"#series.symbolSize\">series.symbolSize</a> can be set as a callback function, where symbol size can be calculated by values of a certain dimension.</li>\n<li>Values in other dimensions can be shown by <a href=\"#tooltip.formatter\">tooltip.formatter</a> or <a href=\"#series.label.formatter\">series.label.formatter</a>.</li>\n</ul>\n</li>\n</ul>\n<p>Especially, when there is one and only one category axis (axis.type is <code class=\"codespan\">&#39;category&#39;</code>), data can be simply be represented by a one-dimension array, like:</p>\n<pre><code class=\"lang-js\">xAxis: {\n    data: [&#39;a&#39;, &#39;b&#39;, &#39;m&#39;, &#39;n&#39;]\n},\nseries: [{\n    // Each item corresponds to each item in xAxis.data.\n    data: [23,  44,  55,  19]\n    // In fact, it is the simplification of the format below:\n    // data: [[0, 23], [1, 44], [2, 55], [3, 19]]\n}]\n</code></pre>\n<p><br>\n<strong>Relationship between &quot;value&quot; and <a href=\"#xAxis.type\">axis.type</a></strong></p>\n<ul>\n<li><p>When a dimension corresponds to a value axis (axis.type is <code class=\"codespan\">&#39;value&#39;</code> or <code class=\"codespan\">&#39;log&#39;</code>):</p>\n<p>  The value can be a <code class=\"codespan\">number</code> (like <code class=\"codespan\">12</code>) (can also be a number in a <code class=\"codespan\">string</code> format, like <code class=\"codespan\">&#39;12&#39;</code>).</p>\n</li>\n<li><p>When a dimension corresponds to a category axis (axis.type is <code class=\"codespan\">&#39;category&#39;</code>):</p>\n<p>  The value should be the ordinal of the axis.data (based on <code class=\"codespan\">0</code>), the string value of the axis.data. For example:</p>\n<pre><code class=\"lang-js\">  xAxis: {\n      type: &#39;category&#39;,\n      data: [&#39;Monday&#39;, &#39;Tuesday&#39;, &#39;Wednesday&#39;, &#39;Thursday&#39;]\n  },\n  yAxis: {\n      type: &#39;category&#39;,\n      data: [&#39;a&#39;, &#39;b&#39;, &#39;m&#39;, &#39;n&#39;, &#39;p&#39;, &#39;q&#39;]\n  },\n  series: [{\n      data: [\n          // xAxis      yAxis\n          [  0,           0,    2  ], // This point is located at xAxis: &#39;Monday&#39;, yAxis: &#39;a&#39;.\n          [  &#39;Thursday&#39;,  2,    1  ], // This point is located at xAxis: &#39;Thursday&#39;, yAxis: &#39;m&#39;.\n          [  2,          &#39;p&#39;,   2  ], // This point is located at xAxis: &#39;Wednesday&#39;, yAxis: &#39;p&#39;.\n          [  3,           3,    5  ]\n      ]\n  }]\n</code></pre>\n<p>  There is an example of double category axes: <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=scatter-punchCard\" target=\"_blank\">Github Punchcard</a>.</p>\n</li>\n<li><p>When a dimension corresponds to a time axis (type is <code class=\"codespan\">&#39;time&#39;</code>), the value can be:</p>\n<ul>\n<li>a timestamp, like <code class=\"codespan\">1484141700832</code>, which represents a UTC time.</li>\n<li>a date string, in one of the formats below:<ul>\n<li>a subset of <a href=\"http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15\" target=\"_blank\">ISO 8601</a>, only including (all of these are treated as local time unless timezone is specified, which is consistent with <a href=\"https://momentjs.com/\" target=\"_blank\">moment</a>):<ul>\n<li>only part of year/month/date/time are specified: <code class=\"codespan\">&#39;2012-03&#39;</code>, <code class=\"codespan\">&#39;2012-03-01&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 05&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 05:06&#39;</code>.</li>\n<li>separated by <code class=\"codespan\">&quot;T&quot;</code> or a space: <code class=\"codespan\">&#39;2012-03-01T12:22:33.123&#39;</code>, <code class=\"codespan\">&#39;2012-03-01 12:22:33.123&#39;</code>.</li>\n<li>timezone specified: <code class=\"codespan\">&#39;2012-03-01T12:22:33Z&#39;</code>, <code class=\"codespan\">&#39;2012-03-01T12:22:33+8000&#39;</code>, <code class=\"codespan\">&#39;2012-03-01T12:22:33-05:00&#39;</code>.</li>\n</ul>\n</li>\n<li>other date string format (all of these are treated as local time):\n<code class=\"codespan\">&#39;2012&#39;</code>, <code class=\"codespan\">&#39;2012-3-1&#39;</code>, <code class=\"codespan\">&#39;2012/3/1&#39;</code>, <code class=\"codespan\">&#39;2012/03/01&#39;</code>,\n<code class=\"codespan\">&#39;2009/6/12 2:00&#39;</code>, <code class=\"codespan\">&#39;2009/6/12 2:05:08&#39;</code>, <code class=\"codespan\">&#39;2009/6/12 2:05:08.123&#39;</code>.</li>\n</ul>\n</li>\n<li>a JavaScript Date instance created by user:<ul>\n<li>Caution, when using a data string to create a Date instance, <a href=\"http://dygraphs.com/date-formats.html\" target=\"_blank\">browser differences and inconsistencies</a> should be considered.</li>\n<li>For example: In chrome, <code class=\"codespan\">new Date(&#39;2012-01-01&#39;)</code> is treated as a Jan 1st 2012 in UTC, while <code class=\"codespan\">new Date(&#39;2012-1-1&#39;)</code> and <code class=\"codespan\">new Date(&#39;2012/01/01&#39;)</code> are treated as Jan 1st 2012 in local timezone. In safari <code class=\"codespan\">new Date(&#39;2012-1-1&#39;)</code> is not supported.</li>\n<li>So if you intent to perform <code class=\"codespan\">new Date(dateString)</code>, it is strongly recommended to use a time parse library (e.g., <a href=\"https://momentjs.com/\" target=\"_blank\">moment</a>), or use <code class=\"codespan\">echarts.number.parseDate</code>, or check <a href=\"http://dygraphs.com/date-formats.html\" target=\"_blank\">this</a>.</li>\n</ul>\n</li>\n</ul>\n</li>\n</ul>\n<p><br>\n<strong>Customize a data item:</strong></p>\n<p>When needing to customize a data item, it can be set as an object, where property <code class=\"codespan\">value</code> reprensent real value. For example:</p>\n<pre><code class=\"lang-js\">[\n    12,\n    24,\n    {\n        value: [24, 32],\n        // label style, only works in this data item.\n        label: {},\n        // item style, only works in this data item.\n        itemStyle:{}\n    },\n    33\n]\n// Or\n[\n    [12, 332],\n    [24, 32],\n    {\n        value: [24, 32],\n        // label style, only works in this data item.\n        label: {},\n        // item style, only works in this data item.\n        itemStyle:{}\n    },\n    [33, 31]\n]\n</code></pre>\n<p><br>\n<strong>Empty value:</strong></p>\n<p><code class=\"codespan\">&#39;-&#39;</code> or <code class=\"codespan\">null</code> or <code class=\"codespan\">undefined</code> or <code class=\"codespan\">NaN</code> can be used to describe that a data item does not exist (ps：<em>not exist</em> does not means its value is <code class=\"codespan\">0</code>).</p>\n<p>For example, line chart can break when encounter an empty value, and scatter chart do not display graphic elements for empty values.</p>\n<p><br><br></p>\n","items":{"type":"Object","properties":{"name":{"type":["string"],"description":"<p>Name of data item.</p>\n"},"value":{"type":["number"],"description":"<p>Value of data item.</p>\n"},"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}},"decal(Object | 'none')":{"type":["*"],"description":"<p>The style of the decal pattern. It works only if <a href=\"#aria.enabled\">aria.enabled</a> and <a href=\"#aria.decal.show\">aria.decal.show</a> are both set to be <code class=\"codespan\">true</code>.</p>\n<p>If it is set to be <code class=\"codespan\">&#39;none&#39;</code>, no decal will be used.</p>\n","properties":{"symbol(string|string[]) = 'rect'":{"type":["*"],"description":"<p>The symbol type of the decal. If it is in the type of <code class=\"codespan\">string[]</code>, it means the symbols are used one by one.</p>\n<p>Icon types provided by ECharts includes</p>\n<p><code class=\"codespan\">&#39;circle&#39;</code>, <code class=\"codespan\">&#39;rect&#39;</code>, <code class=\"codespan\">&#39;roundRect&#39;</code>, <code class=\"codespan\">&#39;triangle&#39;</code>, <code class=\"codespan\">&#39;diamond&#39;</code>, <code class=\"codespan\">&#39;pin&#39;</code>, <code class=\"codespan\">&#39;arrow&#39;</code>, <code class=\"codespan\">&#39;none&#39;</code></p>\n<p>It can be set to an image with <code class=\"codespan\">&#39;image://url&#39;</code> , in which URL is the link to an image, or <code class=\"codespan\">dataURI</code> of an image.</p>\n<p>An image URL example:</p>\n<pre><code>&#39;image://http://xxx.xxx.xxx/a/b.png&#39;\n</code></pre><p>A <code class=\"codespan\">dataURI</code> example:</p>\n<pre><code>&#39;image://data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7&#39;\n</code></pre><p>Icons can be set to arbitrary vector path via <code class=\"codespan\">&#39;path://&#39;</code> in ECharts. As compared with a raster image, vector paths prevent jagging and blurring when scaled, and have better control over changing colors. The size of the vector icon will be adapted automatically. Refer to <a href=\"http://www.w3.org/TR/SVG/paths.html#PathData\" target=\"_blank\">SVG PathData</a> for more information about the format of the path. You may export vector paths from tools like Adobe </p>\n<p>For example:</p>\n<pre><code>&#39;path://M30.9,53.2C16.8,53.2,5.3,41.7,5.3,27.6S16.8,2,30.9,2C45,2,56.4,13.5,56.4,27.6S45,53.2,30.9,53.2z M30.9,3.5C17.6,3.5,6.8,14.4,6.8,27.6c0,13.3,10.8,24.1,24.101,24.1C44.2,51.7,55,40.9,55,27.6C54.9,14.4,44.1,3.5,30.9,3.5z M36.9,35.8c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H36c0.5,0,0.9,0.4,0.9,1V35.8z M27.8,35.8 c0,0.601-0.4,1-0.9,1h-1.3c-0.5,0-0.9-0.399-0.9-1V19.5c0-0.6,0.4-1,0.9-1H27c0.5,0,0.9,0.4,0.9,1L27.8,35.8L27.8,35.8z&#39;\n</code></pre>"},"symbolSize":{"type":["number"],"description":"<p>Range of values: <code class=\"codespan\">0</code> to <code class=\"codespan\">1</code>, representing the size of symbol relative to decal.</p>\n","default":1},"symbolKeepAspect":{"type":["boolean"],"description":"<p>Whether or not to keep the aspect ratio of the pattern.</p>\n","default":true},"color":{"type":["string"],"description":"<p>For the color of the decal pattern, it is recommended to use a translucent color, which can be superimposed on the color of the series itself.</p>\n","default":"'rgba(0, 0, 0, 0.2)'"},"backgroundColor":{"type":["string"],"description":"<p>The background color of the decal will be over the color of the series itself, under the decal pattern.</p>\n","default":null},"dashArrayX(number | number[] | (number | number[])[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayX</code> controls the horizontal pattern pattern. When its value is of type <code class=\"codespan\">number</code> or <code class=\"codespan\">number[]</code>, it is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is of type <code class=\"codespan\">number</code>, it means that the pattern and the blank space are of this value respectively. For example, <code class=\"codespan\">5</code> means the pattern with width 5 is displayed first, then 5 pixels empty, then the pattern with width 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of an array of values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels wide, then 10 pixels empty, then the pattern is 2 pixels wide, then 6 pixels empty, then the pattern is 5 pixels wide...</p>\n</li>\n<li><p>If of type <code class=\"codespan\">(number | number[])[]</code>, it means that each row is a loop with an array of values for the pattern and blank space. For example: <code class=\"codespan\">[10, [2, 5]]</code> means that the first line will be 10 pixels by 10 pixels and empty space, the second line will be 2 pixels by 2 pixels and empty space, and the third line will be 10 pixels by 10 pixels and empty space...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"dashArrayY(number | number[]) = 5":{"type":["*"],"description":"<p>The basic pattern of the decal pattern is an infinite loop in the form of <code class=\"codespan\">Pattern - Blank - Pattern - Blank - Pattern - Blank</code> both horizontally and vertically, respectively. By setting the length of each pattern and blank, complex pattern effects can be achieved.</p>\n<p><code class=\"codespan\">dashArrayY</code> controls the horizontal pattern pattern. Similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray\" target=\"_blank\">SVG stroke-dasharray</a>.</p>\n<ul>\n<li><p>If it is a <code class=\"codespan\">number</code> type, it means the pattern and the blank are each of this value. For example, <code class=\"codespan\">5</code> means that the pattern with a height of 5 is displayed first, then 5 pixels empty, then the pattern with a height of 5 is displayed...</p>\n</li>\n<li><p>In the case of <code class=\"codespan\">number[]</code> type, it means that the pattern and empty space are loops of sequential array values. For example: <code class=\"codespan\">[5, 10, 2, 6]</code> means the pattern is 5 pixels high, then 10 pixels empty, then the pattern is 2 pixels high, then 6 pixels empty, then the pattern is 5 pixels high...</p>\n</li>\n</ul>\n<p>This interface can be better understood with the following examples.</p>\n<iframe  data-src=\"https://echarts.apache.org/next/examples/en/view.html?c=doc-example/aria-decal&edit=1&reset=1\" width=\"700\" height=\"300\"></iframe>\n\n"},"rotation":{"type":["number"],"description":"<p>The overall rotation angle (in radians) of the pattern, in the range from `-Math.</p>\n","default":0},"maxTileWidth":{"type":["number"],"description":"<p>The upper limit of the width of the generated pattern before it is duplicated. Usually this value is not necessary, but you can try to increase it if you notice discontinuous seams in the pattern when it repeats.</p>\n","default":512},"maxTileHeight":{"type":["number"],"description":"<p>The upper limit of the height of the generated pattern before it repeats. This value is usually not necessary to set, but you can try to increase it if you find that the pattern has discontinuous seams when it is repeated.</p>\n","default":512}}}}},"emphasis":{"type":["Object"],"description":"","properties":{"itemStyle":{"type":["Object"],"description":"","properties":{"color":{"type":["Color"],"description":"\n\n<p> color. </p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","uiControl":{"type":"color"},"default":null},"borderColor":{"type":["Color"],"description":"\n\n<p> border color, whose format is similar to that of <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color"},"default":"'#000'"},"borderWidth":{"type":["number"],"description":"\n\n<p> border width. No border when it is set to be 0.</p>\n","uiControl":{"type":"number","value":"0","min":"0","step":"0.5"},"default":0},"borderType":{"type":["string"],"description":"\n\n<p>Border type, which can be <code class=\"codespan\">&#39;solid&#39;</code>, <code class=\"codespan\">&#39;dashed&#39;</code>, or <code class=\"codespan\">&#39;dotted&#39;</code>. <code class=\"codespan\">&#39;solid&#39;</code> by default.</p>\n","uiControl":{"type":"enum","default":"solid","options":"solid,dashed,dotted"},"default":"'solid'"},"shadowBlur":{"type":["number"],"description":"\n\n<p>Size of shadow blur. This attribute should be used along with <code class=\"codespan\">shadowColor</code>,<code class=\"codespan\">shadowOffsetX</code>, <code class=\"codespan\">shadowOffsetY</code> to set shadow to component.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">{\n    shadowColor: &#39;rgba(0, 0, 0, 0.5)&#39;,\n    shadowBlur: 10\n}\n</code></pre>\n","uiControl":{"type":"number","default":"","min":"0","step":"0.5"}},"shadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color. Support same format as <code class=\"codespan\">color</code>.</p>\n","uiControl":{"type":"color","default":""}},"shadowOffsetX":{"type":["number"],"description":"\n\n<p>Offset distance on the horizontal direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"shadowOffsetY":{"type":["number"],"description":"\n\n<p>Offset distance on the vertical direction of shadow.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"opacity":{"type":["number"],"description":"\n\n<p>Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.</p>\n","uiControl":{"type":"number","default":"1","min":"0","max":"1","step":"0.01"}}}}}},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series data.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<blockquote>\n<p><strong>Notice：</strong>series.data.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}}},"clip":{"type":["boolean"],"description":"\n\n\n\n<blockquote>\n<p>Since <code class=\"codespan\">v4.4.0</code></p>\n</blockquote>\n<p>If clip the overflow on the coordinate system. Clip results varies between series:</p>\n<ul>\n<li>Scatter：Ignore the symbols exceeds the coordinate system. Not clip the elements.</li>\n<li>Bar：Clip all the overflowed. With bar width kept.</li>\n<li>Line：Clip the overflowed line.</li>\n<li>Lines: Clip all the overflowed.</li>\n<li>Candlestick: Ignore the elements exceeds the coordinate system.</li>\n<li>Custom: Clip all the olverflowed.</li>\n</ul>\n<p>All these series have default value <code class=\"codespan\">true</code> except custom series. Set it to <code class=\"codespan\">false</code> if you don&#39;t want to clip.</p>\n","uiControl":{"type":"boolean","default":"false"},"default":false},"zlevel":{"type":["number"],"description":"<p><code class=\"codespan\">zlevel</code> value of all graphical elements in custom series.</p>\n<p><code class=\"codespan\">zlevel</code> is used to make layers with Canvas. Graphical elements with different <code class=\"codespan\">zlevel</code> values will be placed in different Canvases, which is a common optimization technique. We can put those frequently changed elements (like those with animations) to a separate <code class=\"codespan\">zlevel</code>. Notice that too many Canvases will increase memory cost, and should be used carefully on mobile phones to avoid crash.</p>\n<p>Canvases with bigger <code class=\"codespan\">zlevel</code> will be placed on Canvases with smaller <code class=\"codespan\">zlevel</code>.</p>\n","default":0},"z":{"type":["number"],"description":"<p><code class=\"codespan\">z</code> value of all graphical elements in custom series, which controls order of drawing graphical components. Components with smaller <code class=\"codespan\">z</code> values may be overwritten by those with larger <code class=\"codespan\">z</code> values.</p>\n<p><code class=\"codespan\">z</code> has a lower priority to <code class=\"codespan\">zlevel</code>, and will not create new Canvas.</p>\n","default":2},"silent":{"type":["boolean"],"description":"\n\n<p>Whether to ignore mouse events. Default value is false, for triggering and responding to mouse events.</p>\n","uiControl":{"type":"boolean"},"default":false},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut"},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut"},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0},"tooltip":{"type":["*"],"description":"<p>tooltip settings in this series.</p>\n","properties":{"position":{"type":["string","Array"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The position of the tooltip&#39;s floating layer, which would follow the position of mouse by default.</p>\n<p>Options:</p>\n<ul>\n<li><p><code class=\"codespan\">Array</code></p>\n<p>  Display the position of tooltip&#39;s floating layer through array, which supports absolute position and relative percentage.</p>\n<p>  Example:</p>\n<pre><code class=\"lang-js\">  // absolute position, which is 10px to the left side and 10px to the top side of the container\n  position: [10, 10]\n  // relative position, in the exact center of the container\n  position: [&#39;50%&#39;, &#39;50%&#39;]\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">Function</code></p>\n<p>  Callback function in the following form:</p>\n<pre><code class=\"lang-js\">  (point: Array, params: Object|Array.&lt;Object&gt;, dom: HTMLDomElement, rect: Object, size: Object) =&gt; Array\n</code></pre>\n<p>  <strong>Parameters:</strong><br>\n  point: Mouse position.<br>\n  param: The same as formatter.<br>\n  dom: The DOM object of tooltip.<br>\n  rect: It is valid only when mouse is on graphic elements, which stands for a bounding box with <code class=\"codespan\">x</code>, <code class=\"codespan\">y</code>, <code class=\"codespan\">width</code>, and <code class=\"codespan\">height</code>.<br>\n  size: The size of dom echarts container. For example: <code class=\"codespan\">{contentSize: [width, height], viewSize: [width, height]}</code>. <br></p>\n<p>  <strong>Return:</strong><br>\n  Return value is an array standing for tooltip position, which can be absolute pixels, or relative percentage.<br>\n  Or can be an object, like <code class=\"codespan\">{left: 10, top: 30}</code>, or <code class=\"codespan\">{right: &#39;20%&#39;, bottom: 40}</code>.<br></p>\n<p>  For example:</p>\n<pre><code class=\"lang-js\">  position: function (point, params, dom, rect, size) {\n      // fixed at top\n      return [point[0], &#39;10%&#39;];\n  }\n</code></pre>\n<p>  Or:</p>\n<pre><code class=\"lang-js\">  position: function (pos, params, dom, rect, size) {\n      // tooltip will be fixed on the right if mouse hovering on the left,\n      // and on the left if hovering on the right.\n      var obj = {top: 60};\n      obj[[&#39;left&#39;, &#39;right&#39;][+(pos[0] &lt; size.viewSize[0] / 2)]] = 5;\n      return obj;\n  }\n</code></pre>\n</li>\n<li><p><code class=\"codespan\">&#39;inside&#39;</code></p>\n<p> Center position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;top&#39;</code></p>\n<p>  Top position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;left&#39;</code></p>\n<p>  Left position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;right&#39;</code></p>\n<p>  Right position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n<li><p><code class=\"codespan\">&#39;bottom&#39;</code></p>\n<p>  Bottom position of the graphic element where the mouse is in, which is only valid when <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.</p>\n</li>\n</ul>\n"},"formatter":{"type":["string","Function"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The content formatter of tooltip&#39;s floating layer which supports string template and callback function.</p>\n<p><strong>1. String template</strong></p>\n<p>The template variables are <code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> and <code class=\"codespan\">{e}</code>, which stands for series name, data name and data value and ect. When <a href=\"#tooltip.trigger\">trigger</a> is set to be <code class=\"codespan\">&#39;axis&#39;</code>, there may be data from multiple series. In this time, series index can be refered as <code class=\"codespan\">{a0}</code>, <code class=\"codespan\">{a1}</code>, or <code class=\"codespan\">{a2}</code>.</p>\n<p><code class=\"codespan\">{a}</code>, <code class=\"codespan\">{b}</code>, <code class=\"codespan\">{c}</code>, <code class=\"codespan\">{d}</code> have different meanings for different series types:</p>\n<ul>\n<li><p>Line (area) charts, bar (column) charts, K charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for category name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Scatter (bubble) charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Map: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for area name, <code class=\"codespan\">{c}</code> for merging data, <code class=\"codespan\">{d}</code> for none;</p>\n</li>\n<li><p>Pie charts, gauge charts, funnel charts: <code class=\"codespan\">{a}</code> for series name, <code class=\"codespan\">{b}</code> for data item name, <code class=\"codespan\">{c}</code> for data value, <code class=\"codespan\">{d}</code> for percentage.</p>\n</li>\n</ul>\n<p><strong>Example: </strong></p>\n<pre><code class=\"lang-js\">formatter: &#39;{b0}: {c0}&lt;br /&gt;{b1}: {c1}&#39;\n</code></pre>\n<p><strong>2. Callback function</strong></p>\n<p>The format of callback function:</p>\n<pre><code class=\"lang-js\">(params: Object|Array, ticket: string, callback: (ticket: string, html: string)) =&gt; string\n</code></pre>\n<p>The first parameter <code class=\"codespan\">params</code> is the data that the formatter needs. Its format is shown as follows:</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n    // the percentage of pie chart\n    percent: number,\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p>When <a href=\"#tooltip.trigger\">trigger</a> is <code class=\"codespan\">&#39;axis&#39;</code>, or when tooltip is triggered by <a href=\"#xAxis.axisPointer\">axisPointer</a>, <code class=\"codespan\">params</code> is the data array of multiple series. The content of each item of the array is the same as above. Besides,</p>\n<pre><code class=\"lang-js\">{\n    componentType: &#39;series&#39;,\n    // Series type\n    seriesType: string,\n    // Series index in option.series\n    seriesIndex: number,\n    // Series name\n    seriesName: string,\n    // Data name, or category name\n    name: string,\n    // Data index in input data array\n    dataIndex: number,\n    // Original data as input\n    data: Object,\n    // Value of data. In most series it is the same as data.\n    // But in some series it is some part of the data (e.g., in map, radar)\n    value: number|Array|Object,\n    // encoding info of coordinate system\n    // Key: coord, like (&#39;x&#39; &#39;y&#39; &#39;radius&#39; &#39;angle&#39;)\n    // value: Must be an array, not null/undefined. Contain dimension indices, like:\n    // {\n    //     x: [2] // values on dimension index 2 are mapped to x axis.\n    //     y: [0] // values on dimension index 0 are mapped to y axis.\n    // }\n    encode: Object,\n    // dimension names list\n    dimensionNames: Array&lt;String&gt;,\n    // data dimension index, for example 0 or 1 or 2 ...\n    // Only work in `radar` series.\n    dimensionIndex: number,\n    // Color of data\n    color: string,\n\n\n\n}\n</code></pre>\n<p>Note: the usage of encode and dimensionNames can be:</p>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    source: [\n        [&#39;Matcha Latte&#39;, 43.3, 85.8, 93.7],\n        [&#39;Milk Tea&#39;, 83.1, 73.4, 55.1],\n        [&#39;Cheese Cocoa&#39;, 86.4, 65.2, 82.5],\n        [&#39;Walnut Brownie&#39;, 72.4, 53.9, 39.1]\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.encode.y[0]]\n</code></pre>\n<p>If data is:</p>\n<pre><code class=\"lang-js\">dataset: {\n    dimensions: [&#39;product&#39;, &#39;2015&#39;, &#39;2016&#39;, &#39;2017&#39;],\n    source: [\n        {product: &#39;Matcha Latte&#39;, &#39;2015&#39;: 43.3, &#39;2016&#39;: 85.8, &#39;2017&#39;: 93.7},\n        {product: &#39;Milk Tea&#39;, &#39;2015&#39;: 83.1, &#39;2016&#39;: 73.4, &#39;2017&#39;: 55.1},\n        {product: &#39;Cheese Cocoa&#39;, &#39;2015&#39;: 86.4, &#39;2016&#39;: 65.2, &#39;2017&#39;: 82.5},\n        {product: &#39;Walnut Brownie&#39;, &#39;2015&#39;: 72.4, &#39;2016&#39;: 53.9, &#39;2017&#39;: 39.1}\n    ]\n}\n</code></pre>\n<p>We can get values that corresponding to y axis by:</p>\n<pre><code class=\"lang-js\">params.value[params.dimensionNames[params.encode.y[0]]]\n</code></pre>\n<p><strong>Note: </strong>Using array to present all the parameters in ECharts 2.x is not supported anymore.</p>\n<p>The second parameter <code class=\"codespan\">ticket</code> is the asynchronous callback flag which should be used along with the third parameter <code class=\"codespan\">callback</code> when it is used.</p>\n<p>The third parameter <code class=\"codespan\">callback</code> is asynchronous callback. When the content of tooltip is acquired asynchronously, <code class=\"codespan\">ticket</code> and <code class=\"codespan\">htm</code> as introduced above can be used to update tooltip with callback.</p>\n<p>Example:</p>\n<pre><code class=\"lang-js\">formatter: function (params, ticket, callback) {\n    $.get(&#39;detail?name=&#39; + params.name, function (content) {\n        callback(ticket, toHTML(content));\n    });\n    return &#39;Loading&#39;;\n}\n</code></pre>\n"},"backgroundColor":{"type":["Color"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The background color of tooltip&#39;s floating layer.</p>\n","default":"'rgba(50,50,50,0.7)'"},"borderColor":{"type":["Color"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border color of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"color","default":"#333"},"default":"'#333'"},"borderWidth":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The border width of tooltip&#39;s floating layer.</p>\n","uiControl":{"type":"number","default":"0","step":"0.5"},"default":0},"padding":{"type":["number"],"description":"\n\n\n\n\n<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n\n\n<p>The floating layer of tooltip space around content. The unit is px. Default values for each position are 5. And they can be set to different values with left, right, top, and bottom.</p>\n<p>Examples: </p>\n<pre><code class=\"lang-js\">// Set padding to be 5\npadding: 5\n// Set the top and bottom paddings to be 5, and left and right paddings to be 10\npadding: [5, 10]\n// Set each of the four paddings seperately\npadding: [\n    5,  // up\n    10, // right\n    5,  // down\n    10, // left\n]\n</code></pre>\n","uiControl":{"type":"vector","min":"0","dims":"T,R,B,L"},"default":5},"textStyle":{"type":["Object"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>The text syle of tooltip&#39;s floating layer.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"'#fff'"},"default":"'#fff'"},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"14","min":"1","step":"1"},"default":14},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"extraCssText":{"type":["string"],"description":"<p><br></p>\n<blockquote>\n<p><strong>Notice：</strong>series.tooltip only works when <a href=\"#tooltip.trigger\">tooltip.trigger</a> is <code class=\"codespan\">&#39;item&#39;</code>.<br></p>\n</blockquote>\n<p>Extra CSS style for floating layer. The following is an example for adding shadow.</p>\n<pre><code class=\"lang-js\">extraCssText: &#39;box-shadow: 0 0 3px rgba(0, 0, 0, 0.3);&#39;\n</code></pre>\n"}}}}}]},"properties":{}},"color":{"type":["Array"],"description":"<p>The color list of palette. If no color is set in series, the colors would be adopted sequentially and circularly from this list as the colors of series.</p>\n<p>Defaults:</p>\n<pre><code class=\"lang-js\">[&#39;#c23531&#39;,&#39;#2f4554&#39;, &#39;#61a0a8&#39;, &#39;#d48265&#39;, &#39;#91c7ae&#39;,&#39;#749f83&#39;,  &#39;#ca8622&#39;, &#39;#bda29a&#39;,&#39;#6e7074&#39;, &#39;#546570&#39;, &#39;#c4ccd3&#39;]\n</code></pre>\n","properties":{}},"backgroundColor":{"type":["Color"],"description":"<p>Background color. Defaults to have no background.</p>\n<blockquote>\n<p>Color can be represented in RGB, for example <code class=\"codespan\">&#39;rgb(128, 128, 128)&#39;</code>. RGBA can be used when you need alpha channel, for example <code class=\"codespan\">&#39;rgba(128, 128, 128, 0.5)&#39;</code>. You may also use hexadecimal format, for example <code class=\"codespan\">&#39;#ccc&#39;</code>. Gradient color and texture are also supported besides single colors.</p>\n<pre><code class=\"lang-js\">// Linear gradient. First four parameters are x0, y0, x2, and y2, each ranged from 0 to 1, standing for percentage in the bounding box. If global is `true`, then the first four parameters are in absolute pixel positions.\ncolor: {\n    type: &#39;linear&#39;,\n    x: 0,\n    y: 0,\n    x2: 0,\n    y2: 1,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Radial gradient. First three parameters are x and y positions of center, and radius, similar to linear gradient.\ncolor: {\n    type: &#39;radial&#39;,\n    x: 0.5,\n    y: 0.5,\n    r: 0.5,\n    colorStops: [{\n        offset: 0, color: &#39;red&#39; // color at 0% position\n    }, {\n        offset: 1, color: &#39;blue&#39; // color at 100% position\n    }],\n    global: false // false by default\n}\n// Fill with texture\ncolor: {\n    image: imageDom, // HTMLImageElement, and HTMLCanvasElement are supported, while string path is not supported\n    repeat: &#39;repeat&#39; // whether to repeat texture, whose value can be repeat-x, repeat-y, or no-repeat\n}\n</code></pre>\n</blockquote>\n","properties":{}},"textStyle":{"type":["Object"],"description":"<p>Global font style.</p>\n","properties":{"color":{"type":["Color"],"description":"\n\n<p> text color.</p>\n","uiControl":{"type":"color","default":"null"},"default":"\"#fff\""},"fontStyle":{"type":["string"],"description":"\n\n<p> font style.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;italic&#39;</code></li>\n<li><code class=\"codespan\">&#39;oblique&#39;</code></li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,italic,oblique"},"default":"'normal'"},"fontWeight":{"type":["string","number"],"description":"\n\n<p> font thick weight.</p>\n<p>Options are:</p>\n<ul>\n<li><code class=\"codespan\">&#39;normal&#39;</code></li>\n<li><code class=\"codespan\">&#39;bold&#39;</code></li>\n<li><code class=\"codespan\">&#39;bolder&#39;</code></li>\n<li><code class=\"codespan\">&#39;lighter&#39;</code></li>\n<li>100 | 200 | 300 | 400...</li>\n</ul>\n","uiControl":{"type":"enum","default":"normal","options":"normal,bold,bolder,lighter"},"default":"normal"},"fontFamily":{"type":["string"],"description":"\n\n<p> font family.</p>\n<p>Can also be &#39;serif&#39; , &#39;monospace&#39;, ...</p>\n","uiControl":{"type":"enum","default":"sans-serif","options":"sans-serif,serif,monospace,Arial,Courier New"},"default":"'sans-serif'"},"fontSize":{"type":["number"],"description":"\n\n<p> font size.</p>\n","uiControl":{"type":"number","default":"12","min":"1","step":"1"},"default":12},"lineHeight":{"type":["number"],"description":"\n\n<p>Line height of the text fragment.</p>\n<p>If <code class=\"codespan\">lineHeight</code> is not set in <code class=\"codespan\">rich</code>, <code class=\"codespan\">lineHeight</code> in parent level will be used. For example:</p>\n<pre><code class=\"lang-js\">{\n    lineHeight: 56,\n    rich: {\n        a: {\n            // `lineHeight` is not set, then it will be 56\n        }\n    }\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","step":"1","default":"12"}},"width":{"type":["number"],"description":"\n\n<p>Width of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"height":{"type":["number"],"description":"\n\n<p>Height of text block.</p>\n","uiControl":{"type":"number","default":"50","min":"1","max":"200","step":"1"}},"textBorderColor":{"type":["Color"],"description":"\n\n<p>Storke color of the text.</p>\n","uiControl":{"type":"color"}},"textBorderWidth":{"type":["number"],"description":"\n\n<p>Storke line width of the text.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"}},"textShadowColor":{"type":["Color"],"description":"\n\n<p>Shadow color of the text itself.</p>\n","uiControl":{"type":"color","default":"#000"},"default":"'transparent'"},"textShadowBlur":{"type":["number"],"description":"\n\n<p>Shadow blue of the text itself.</p>\n","uiControl":{"type":"number","min":"0","step":"0.5"},"default":0},"textShadowOffsetX":{"type":["number"],"description":"\n\n<p>Shadow X offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"textShadowOffsetY":{"type":["number"],"description":"\n\n<p>Shadow Y offset of the text itself.</p>\n","uiControl":{"type":"number","step":"0.5"},"default":0},"overflow":{"type":["string"],"description":"\n\n<p>Determine how to display the text when it&#39;s overflow. Available when <code class=\"codespan\">width</code> is set.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the text and trailing with <code class=\"codespan\">ellipsis</code>.</li>\n<li><code class=\"codespan\">&#39;break&#39;</code> Break by word</li>\n<li><code class=\"codespan\">&#39;breakAll&#39;</code> Break by character.</li>\n</ul>\n","uiControl":{"type":"enum","options":"truncate,break,breakAll"},"default":"'none'"},"ellipsis":{"type":["string"],"description":"<p>Ellipsis to be displayed when <code class=\"codespan\">overflow</code> is set to <code class=\"codespan\">truncate</code>.</p>\n","default":"'...'"},"lineOverflow":{"type":["string"],"description":"<p>Determine how to display the text when it&#39;s overflow on height.</p>\n<ul>\n<li><code class=\"codespan\">&#39;truncate&#39;</code> Truncate the overflow lines.</li>\n</ul>\n","default":"'none'"}}},"animation":{"type":["boolean"],"description":"\n\n<p>Whether to enable animation.</p>\n","uiControl":{"type":"boolean","default":"true","clean":"true"},"default":true,"properties":{}},"animationThreshold":{"type":["number"],"description":"<p>Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.</p>\n","default":2000,"properties":{}},"animationDuration":{"type":["number","Function"],"description":"\n\n<p>Duration of the first animation, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDuration: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20","clean":"true"},"default":1000,"properties":{}},"animationEasing":{"type":["string"],"description":"\n\n<p>Easing method used for the first animation. Varied easing effects can be found at <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=line-easing\" target=\"_blank\">easing effect example</a>.</p>\n","uiControl":{"type":"enum","options":"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","clean":"true"},"default":"cubicOut","properties":{}},"animationDelay":{"type":["number","Function"],"description":"<p>Delay before updating the first animation, which supports callback function for different data to have different animation effect.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelay: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0,"properties":{}},"animationDurationUpdate":{"type":["number","Function"],"description":"\n\n<p>Time for animation to complete, which supports callback function for different data to have different animation effect:</p>\n<pre><code class=\"lang-js\">animationDurationUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n","uiControl":{"type":"number","min":"0","default":"1000","step":"20"},"default":300,"properties":{}},"animationEasingUpdate":{"type":["string"],"description":"\n\n<p>Easing method used for animation.</p>\n","uiControl":{"type":"enum","options":"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"},"default":"cubicOut","properties":{}},"animationDelayUpdate":{"type":["number","Function"],"description":"<p>Delay before updating animation, which supports callback function for different data to have different animation effects.</p>\n<p>For example:</p>\n<pre><code class=\"lang-js\">animationDelayUpdate: function (idx) {\n    // delay for later data is larger\n    return idx * 100;\n}\n</code></pre>\n<p>See <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=bar-animation-delay\" target=\"_blank\">this example</a> for more information.</p>\n","default":0,"properties":{}},"blendMode":{"type":["string"],"description":"<p>Sets the type of compositing operation to apply when drawing a new shape. See the different type: <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation\" target=\"_blank\">https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation</a>.</p>\n<p>The default is <code class=\"codespan\">&#39;source-over&#39;</code>. Support settings for each series.</p>\n<p><code class=\"codespan\">&#39;lighter&#39;</code> is also a common type of compositing operation. In this mode, the area where the number of graphics is concentrated is superimposed into a high-brightness color (white). It often used to highlight the effect of the area. See example <a href=\"https://echarts.apache.org/next/examples/en/editor.html?c=lines-airline\" target=\"_blank\">Global airline</a></p>\n","default":"'source-over'","properties":{}},"hoverLayerThreshold":{"type":["number"],"description":"<p>When the number of element of the whole chart is larger than <code class=\"codespan\">hoverLayerThreshold</code>, a seperate hover layer is used to render hovered elements.</p>\n<p>The seperate hover layer is used to avoid re-painting the whole canvas when hovering on elements. Instead, the hovered elements are rendered in a seperate layer so that other elements don&#39;t have to be rendered again.</p>\n<p>ECharts 2 use seperate layer for all cases. But it brings some problems like the hovered elements may not covering everything else correctly, or translucent elements may not overlay correctly to each other. And it brings extra member cost due to the extra canvas and may bring burden on mobile devices. So since ECharts 3, the hover layer is not used by default. Only when the element amount is large enough will the hover layer used.</p>\n","default":3000,"properties":{}},"useUTC":{"type":["boolean"],"description":"<p>Whether to use UTC in display.</p>\n<ul>\n<li><code class=\"codespan\">true</code>: When <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;time&#39;</code>, ticks is determined according to UTC, and <code class=\"codespan\">axisLabel</code> and <code class=\"codespan\">tooltip</code> use UTC by default.</li>\n<li><code class=\"codespan\">false</code>: When <code class=\"codespan\">axis.type</code> is <code class=\"codespan\">&#39;time&#39;</code>, ticks is determined according to local time, and <code class=\"codespan\">axisLabel</code> and <code class=\"codespan\">tooltip</code> use local time by default.</li>\n</ul>\n<p>The default value of <code class=\"codespan\">useUTC</code> is false, for sake of considering:</p>\n<ul>\n<li>In many cases, labels should be displayed in local time (whether the time is stored in server in local time or UTC).</li>\n<li>If user uses time string (like &#39;2012-01-02&#39;) in data, it usually means local time if time zone is not specified. Time should be displayed in its original time zone by default.</li>\n</ul>\n<p>Notice: the setting only affects &quot;display time&quot;, not &quot;parse time&quot;.\nFor how time value (like <code class=\"codespan\">1491339540396</code>, <code class=\"codespan\">&#39;2013-01-04&#39;</code>, ...) is parsed in echarts, see <a href=\"#series-line.data\">the time part in date</a>.</p>\n","default":false,"properties":{}},"options":{"type":["Array"],"description":"<p>Option array used in <a href=\"option.html#timeline\" target=\"_blank\">timeline</a>. Each item of this array is an echarts option (<code class=\"codespan\">ECUnitOption</code>).</p>\n","default":"undefined","properties":{}},"media":{"type":["Array"],"description":"<p>See <a href=\"tutorial.html#Responsive%20Mobile-End\" target=\"_blank\">Responsive Mobile-End</a> for details.</p>\n","items":{"type":"Object","properties":{"query":{"type":["Object"],"description":"<p>If more than one properties used, it means &quot;and&quot;.</p>\n","properties":{"minWidth":{"type":["number"],"description":"","default":"undefined"},"maxHeight":{"type":["number"],"description":"","default":"undefined"},"minAspectRatio":{"type":["number"],"description":"<p>That is the radio of <code class=\"codespan\">width / height</code>. The value can be like <code class=\"codespan\">1.3</code>.</p>\n","default":"undefined"}}},"option":{"type":["Object"],"description":"<p>Each item of this array is an echarts option (<code class=\"codespan\">ECUnitOption</code>). It will be applied when this query is matched.</p>\n"}}},"properties":{}}}}}